scmd 3.0.0 → 3.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 41ab93becdd3b11aa43cf2b7465bb06740176732
+  metadata.gz: d8df11392ad93610a721cdfb7c85aa4a2bc3b0a2
+SHA512: 
+  data.tar.gz: c069015a2af2701ac855f12384c2941b39ede49b7e89b9157a83be6214b83034106405a1ad0c52fc016007b65a4d3ced67cb118008a6d7c0fa5cbf56fa3eb0ed
+  metadata.gz: cce48d3004f825e93f42b5e1a397ed5c7dbaff2a4fddcfce0e8acba3586b56286ba9a3dd7952136b73aacdb2eb51cd9ebf3435d35719dfc2cc0384a87193fec6

data/README.md

@@ -121,6 +121,71 @@ reader.gets # => "test\n"
 
 For all the possible options see [posix-spawn](https://github.com/rtomayko/posix-spawn#status).
 
+## Testing
+
+Scmd comes with some testing utilities built in.  Specifically this includes a command spy and a "test mode" API on the main `Scmd` namespace.
+
+### Command Spy
+
+```ruby
+require 'scmd/command_spy'
+spy = Scmd::CommandSpy.new(cmd_str)
+spy.exitstatus = 1
+spy.stdout = 'some test output'
+Assert.stub(Scmd, :new).with(cmd_str){ spy }
+
+cmd = Scmd.new(cmd_str) # => spy
+cmd.run('some input')
+
+cmd.run_called?           # => true
+cmd.run_calls.size        # => 1
+cmd.run_calls.first.input # => 'some input'
+```
+
+The spy is useful for stubbing out system commands that you don't want to call or aren't safe to call in the test suite.  It responds to the same API that commands do but doesn't run any system commands.
+
+### "Test Mode" API
+
+```ruby
+Scmd.add_command(cmd_str){ |cmd| cmd.stdout = 'some output' } # => raises NoMethodError
+
+ENV['SCMD_TEST_MODE'] = '1'
+Scmd.add_command(cmd_str){ |cmd| cmd.stdout = 'some output' }
+Scmd.add_command(cmd_str).with({:env => { :SOME_ENV_VAR => '1' }}) do |cmd|
+  cmd.stdout = 'some other output'
+end
+Scmd.commands.empty? # => false
+
+cmd = Scmd.new(cmd_str)
+cmd.class                 # => Scmd::CommandSpy
+cmd.stdout                # => 'some output'
+cmd.run('some input')
+Scmd.calls.size           # => 1
+Scmd.calls.last.class     # => Scmd::Call
+Scmd.calls.last.cmd_str   # => cmd_str
+Scmd.calls.last.input     # => 'some input'
+Scmd.calls.last.cmd.class # => Scmd::CommandSpy
+
+cmd = Scmd.new(cmd_str, {:env => { 'SOME_ENV_VAR' => '1' }})
+cmd.class                 # => Scmd::CommandSpy
+cmd.stdout                # => 'some other output'
+cmd.run('some input')
+Scmd.calls.size           # => 2
+Scmd.calls.last.class     # => Scmd::Call
+Scmd.calls.last.cmd_str   # => cmd_str
+Scmd.calls.last.input     # => 'some input'
+Scmd.calls.last.cmd.class # => Scmd::CommandSpy
+Scmd.calls.last.cmd.env   # => { 'SOME_ENV_VAR' => '1' }
+
+Scmd.reset
+Scmd.commands.empty? # => true
+Scmd.calls.empty?    # => true
+```
+
+Use these singleton methods on the `Scmd` namespace to add specific command spies in specific contexts and to track command calls (runs, starts).  Use `reset` to reset the state of things.
+
+**Note:** these methods are only available when test mode is enabled (when the `SCMD_TEST_MODE` env var has a non-falsey value).  Otherwise these methods will raise `NoMethodError`.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/scmd.rb

@@ -3,8 +3,46 @@ require 'scmd/command'
 
 module Scmd
 
-  def self.new(*args, &block)
-    Command.new(*args, &block)
+  # Scmd can be run in "test mode".  This means that command spies will be used
+  # in place of "live" commands, each time a command is run or started will be
+  # logged in a collection and option-specific spies can be added and used to
+  # "stub" spies with specific attributes in specific contexts.
+
+  def self.new(*args)
+    if !ENV['SCMD_TEST_MODE']
+      Command.new(*args)
+    else
+      self.commands.get(*args)
+    end
+  end
+
+  def self.commands
+    raise NoMethodError if !ENV['SCMD_TEST_MODE']
+    @commands ||= begin
+      require 'scmd/stored_commands'
+      StoredCommands.new
+    end
+  end
+
+  def self.calls
+    raise NoMethodError if !ENV['SCMD_TEST_MODE']
+    @calls ||= []
+  end
+
+  def self.reset
+    raise NoMethodError if !ENV['SCMD_TEST_MODE']
+    self.calls.clear
+    self.commands.remove_all
+  end
+
+  def self.add_command(cmd_str, &block)
+    self.commands.add(cmd_str, &block)
+  end
+
+  class Call < Struct.new(:cmd_str, :input, :cmd)
+    def initialize(cmd_spy, input)
+      super(cmd_spy.cmd_str, input, cmd_spy)
+    end
   end
 
   TimeoutError = Class.new(::RuntimeError)

data/lib/scmd/command.rb

@@ -88,10 +88,10 @@ module Scmd
       end
     end
 
-    def kill(sig = nil)
+    def kill(signal = nil)
       return if !running?
 
-      send_kill(sig)
+      send_kill(signal)
       wait # indefinitely until cmd is killed
     end
 
@@ -148,8 +148,8 @@ module Scmd
       send_signal 'TERM'
     end
 
-    def send_kill(sig = nil)
-      send_signal(sig || 'KILL')
+    def send_kill(signal = nil)
+      send_signal(signal || 'KILL')
     end
 
     def send_signal(sig)

data/lib/scmd/command_spy.rb

@@ -0,0 +1,121 @@
+require 'scmd'
+
+module Scmd
+
+  class CommandSpy
+
+    attr_reader :cmd_str, :env, :options
+    attr_reader :run_calls, :run_bang_calls, :start_calls
+    attr_reader :wait_calls, :stop_calls, :kill_calls
+    attr_accessor :pid, :exitstatus, :stdout, :stderr
+
+    def initialize(cmd_str, opts = nil)
+      opts ||= {}
+      @cmd_str = cmd_str
+      @env     = opts[:env]
+      @options = opts[:options]
+
+      @run_calls,  @run_bang_calls, @start_calls = [], [], []
+      @wait_calls, @stop_calls,     @kill_calls  = [], [], []
+
+      @running = false
+
+      @stdout, @stderr, @pid, @exitstatus = '', '', 1, 0
+    end
+
+    def run(input = nil)
+      @run_calls.push(InputCall.new(input))
+      Scmd.calls.push(Scmd::Call.new(self, input))
+      self
+    end
+
+    def run_called?
+      !@run_calls.empty?
+    end
+
+    def run!(input = nil)
+      @run_bang_calls.push(InputCall.new(input))
+      Scmd.calls.push(Scmd::Call.new(self, input))
+      self
+    end
+
+    def run_bang_called?
+      !@run_bang_calls.empty?
+    end
+
+    def start(input = nil)
+      @start_calls.push(InputCall.new(input))
+      Scmd.calls.push(Scmd::Call.new(self, input))
+      @running = true
+    end
+
+    def start_called?
+      !@start_calls.empty?
+    end
+
+    def wait(timeout = nil)
+      @wait_calls.push(TimeoutCall.new(timeout))
+      @running = false
+    end
+
+    def wait_called?
+      !@wait_calls.empty?
+    end
+
+    def stop(timeout = nil)
+      @stop_calls.push(TimeoutCall.new(timeout))
+      @running = false
+    end
+
+    def stop_called?
+      !@stop_calls.empty?
+    end
+
+    def kill(signal = nil)
+      @kill_calls.push(SignalCall.new(signal))
+      @running = false
+    end
+
+    def kill_called?
+      !@kill_calls.empty?
+    end
+
+    def running?
+      !!@running
+    end
+
+    def success?
+      @exitstatus == 0
+    end
+
+    def to_s
+      @cmd_str.to_s
+    end
+
+    def ==(other_spy)
+      if other_spy.kind_of?(CommandSpy)
+        self.cmd_str         == other_spy.cmd_str        &&
+        self.env             == other_spy.env            &&
+        self.options         == other_spy.options        &&
+        self.run_calls       == other_spy.run_calls      &&
+        self.run_bang_calls  == other_spy.run_bang_calls &&
+        self.start_calls     == other_spy.start_calls    &&
+        self.wait_calls      == other_spy.wait_calls     &&
+        self.stop_calls      == other_spy.stop_calls     &&
+        self.kill_calls      == other_spy.kill_calls     &&
+        self.pid             == other_spy.pid            &&
+        self.exitstatus      == other_spy.exitstatus     &&
+        self.stdout          == other_spy.stdout         &&
+        self.stderr          == other_spy.stderr
+      else
+        super
+      end
+    end
+
+    InputCall   = Struct.new(:input)
+    TimeoutCall = Struct.new(:timeout)
+    SignalCall  = Struct.new(:signal)
+
+  end
+
+end

data/lib/scmd/stored_commands.rb

@@ -0,0 +1,78 @@
+require 'scmd/command_spy'
+
+module Scmd
+
+  class StoredCommands
+
+    attr_reader :hash
+
+    def initialize
+      @hash = Hash.new{ |h, k| h[k] = Stub.new(k) }
+    end
+
+    def add(cmd_str, &block)
+      @hash[cmd_str].tap{ |s| s.set_default_proc(&block) }
+    end
+
+    def get(cmd_str, opts = nil)
+      @hash[cmd_str].call(opts)
+    end
+
+    def remove(cmd_str)
+      @hash.delete(cmd_str)
+    end
+
+    def remove_all
+      @hash.clear
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    def ==(other_stored_commands)
+      if other_stored_commands.kind_of?(StoredCommands)
+        self.hash == other_stored_commands.hash
+      else
+        super
+      end
+    end
+
+    class Stub
+
+      attr_reader :cmd_str, :hash
+
+      def initialize(cmd_str)
+        @cmd_str = cmd_str
+        @default_proc = proc{ |cmd_spy| } # no-op
+        @hash = {}
+      end
+
+      def set_default_proc(&block)
+        @default_proc = block if block
+      end
+
+      def with(opts, &block)
+        @hash[opts] = block
+        self
+      end
+
+      def call(opts)
+        block = @hash[opts] || @default_proc
+        CommandSpy.new(@cmd_str, opts).tap(&block)
+      end
+
+      def ==(other_stub)
+        if other_stub.kind_of?(Stub)
+          self.cmd_str == other_stub.cmd_str &&
+          self.hash    == other_stub.hash
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/scmd/version.rb

@@ -1,3 +1,3 @@
 module Scmd
-  VERSION = "3.0.0"
+  VERSION = "3.0.1"
 end

data/test/helper.rb

@@ -7,3 +7,5 @@ $LOAD_PATH.unshift(ROOT_PATH)
 
 # require pry for debugging (`binding.pry`)
 require 'pry'
+
+require 'test/support/factory'

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/unit/command_spy_tests.rb

@@ -0,0 +1,228 @@
+require "assert"
+require 'scmd/command_spy'
+
+class Scmd::CommandSpy
+
+  class UnitTests < Assert::Context
+    desc "Scmd::CommandSpy"
+    setup do
+      @spy_class = Scmd::CommandSpy
+    end
+
+  end
+
+  class InitTests < UnitTests
+    setup do
+      @orig_scmd_test_mode = ENV['SCMD_TEST_MODE']
+      ENV['SCMD_TEST_MODE'] = '1'
+      Scmd.reset
+
+      @cmd_str = Factory.string
+      @spy = @spy_class.new(@cmd_str)
+    end
+    teardown do
+      Scmd.reset
+      ENV['SCMD_TEST_MODE'] = @orig_scmd_test_mode
+    end
+    subject{ @spy }
+
+    should have_readers :cmd_str, :env, :options
+    should have_readers :run_calls, :run_bang_calls, :start_calls
+    should have_readers :wait_calls, :stop_calls, :kill_calls
+    should have_accessors :pid, :exitstatus, :stdout, :stderr
+    should have_imeths :run, :run_called?, :run!, :run_bang_called?
+    should have_imeths :start, :start_called?
+    should have_imeths :wait, :wait_called?, :stop, :stop_called?
+    should have_imeths :kill, :kill_called?
+    should have_imeths :running?, :success?
+
+    should "know and return its cmd string" do
+      assert_equal @cmd_str, subject.cmd_str
+      assert_equal @cmd_str, subject.to_s
+    end
+
+    should "default its attrs" do
+      assert_nil subject.env
+      assert_nil subject.options
+
+      assert_equal [], subject.run_calls
+      assert_equal [], subject.run_bang_calls
+      assert_equal [], subject.start_calls
+      assert_equal [], subject.wait_calls
+      assert_equal [], subject.stop_calls
+      assert_equal [], subject.kill_calls
+
+      assert_equal 1,  subject.pid
+      assert_equal 0,  subject.exitstatus
+      assert_equal '', subject.stdout
+      assert_equal '', subject.stderr
+    end
+
+    should "allow specifying env and options" do
+      opts = { Factory.string => Factory.string }
+      cmd = Scmd::Command.new(Factory.string, {
+        :env     => { :SCMD_TEST_VAR => 1 },
+        :options => opts
+      })
+      exp = { 'SCMD_TEST_VAR' => '1' }
+      assert_equal exp,  cmd.env
+      assert_equal opts, cmd.options
+    end
+
+    should "know whether it is running or not" do
+      assert_false subject.running?
+
+      subject.run
+      assert_false subject.running?
+      subject.run!
+      assert_false subject.running?
+
+      subject.start
+      assert_true subject.running?
+      subject.stop
+      assert_false subject.running?
+
+      subject.start
+      subject.wait
+      assert_false subject.running?
+
+      subject.start
+      subject.kill
+      assert_false subject.running?
+    end
+
+    should "know if it was successful" do
+      assert_true subject.success?
+
+      subject.exitstatus = 1
+      assert_false subject.success?
+
+      subject.exitstatus = 0
+      assert_true subject.success?
+
+      subject.exitstatus = Factory.string
+      assert_false subject.success?
+    end
+
+    should "track its run calls" do
+      input = Factory.string
+      subject.run(input)
+
+      assert_equal 1, subject.run_calls.size
+      assert_kind_of InputCall, subject.run_calls.first
+      assert_equal input, subject.run_calls.first.input
+
+      assert_equal 1, Scmd.calls.size
+      assert_kind_of Scmd::Call, Scmd.calls.first
+      assert_equal @cmd_str, Scmd.calls.first.cmd_str
+      assert_equal input,    Scmd.calls.first.input
+      assert_equal subject,  Scmd.calls.first.cmd
+
+      subject.run(Factory.string)
+      assert_equal 2, subject.run_calls.size
+      assert_equal 2, Scmd.calls.size
+    end
+
+    should "track its run! calls" do
+      input = Factory.string
+      subject.run!(input)
+
+      assert_equal 1, subject.run_bang_calls.size
+      assert_kind_of InputCall, subject.run_bang_calls.first
+      assert_equal input, subject.run_bang_calls.first.input
+
+      assert_equal 1, Scmd.calls.size
+      assert_kind_of Scmd::Call, Scmd.calls.first
+      assert_equal @cmd_str, Scmd.calls.first.cmd_str
+      assert_equal input,    Scmd.calls.first.input
+      assert_equal subject,  Scmd.calls.first.cmd
+
+      subject.run!(Factory.string)
+      assert_equal 2, subject.run_bang_calls.size
+      assert_equal 2, Scmd.calls.size
+    end
+
+    should "track its start calls" do
+      input = Factory.string
+      subject.start(input)
+
+      assert_equal 1, subject.start_calls.size
+      assert_kind_of InputCall, subject.start_calls.first
+      assert_equal input, subject.start_calls.first.input
+
+      assert_equal 1, Scmd.calls.size
+      assert_kind_of Scmd::Call, Scmd.calls.first
+      assert_equal @cmd_str, Scmd.calls.first.cmd_str
+      assert_equal input,    Scmd.calls.first.input
+      assert_equal subject,  Scmd.calls.first.cmd
+
+      subject.start(Factory.string)
+      assert_equal 2, subject.start_calls.size
+      assert_equal 2, Scmd.calls.size
+    end
+
+    should "track its wait calls" do
+      timeout = Factory.string
+      subject.wait(timeout)
+
+      assert_equal 1, subject.wait_calls.size
+      assert_kind_of TimeoutCall, subject.wait_calls.first
+      assert_equal timeout, subject.wait_calls.first.timeout
+
+      subject.wait(Factory.string)
+      assert_equal 2, subject.wait_calls.size
+    end
+
+    should "track its stop calls" do
+      timeout = Factory.string
+      subject.stop(timeout)
+
+      assert_equal 1, subject.stop_calls.size
+      assert_kind_of TimeoutCall, subject.stop_calls.first
+      assert_equal timeout, subject.stop_calls.first.timeout
+
+      subject.stop(Factory.string)
+      assert_equal 2, subject.stop_calls.size
+    end
+
+    should "track its kill calls" do
+      signal = Factory.string
+      subject.kill(signal)
+
+      assert_equal 1, subject.kill_calls.size
+      assert_kind_of SignalCall, subject.kill_calls.first
+      assert_equal signal, subject.kill_calls.first.signal
+
+      subject.kill(Factory.string)
+      assert_equal 2, subject.kill_calls.size
+    end
+
+    should "know if it is equal to another cmd spy" do
+      spy1 = @spy_class.new(@cmd_str)
+      spy2 = @spy_class.new(@cmd_str)
+
+      assert_equal spy1, spy2
+
+      a = [
+        :cmd_str,
+        :env,
+        :options,
+        :run_calls,
+        :run_bang_calls,
+        :start_calls,
+        :wait_calls,
+        :stop_calls,
+        :kill_calls,
+        :pid,
+        :exitstatus,
+        :stdout,
+        :stderr
+      ].choice
+      Assert.stub(spy2, a){ Factory.string }
+
+      assert_not_equal spy1, spy2
+    end
+
+  end
+
+end

data/test/unit/command_tests.rb

@@ -8,7 +8,7 @@ class Scmd::Command
     setup do
       @cmd = Scmd::Command.new("echo hi")
     end
-    subject { @cmd }
+    subject{ @cmd }
 
     should have_readers :cmd_str, :env, :options
     should have_readers :pid, :exitstatus, :stdout, :stderr
@@ -29,8 +29,8 @@ class Scmd::Command
       cmd = Scmd::Command.new("echo $SCMD_TEST_VAR", {
         :env => { :SCMD_TEST_VAR => 1 }
       })
-      expected = { 'SCMD_TEST_VAR' => '1' }
-      assert_equal expected, cmd.env
+      exp = { 'SCMD_TEST_VAR' => '1' }
+      assert_equal exp, cmd.env
     end
 
     should "default its options to an empty hash" do

data/test/unit/scmd_tests.rb

@@ -2,6 +2,8 @@ require "assert"
 require 'scmd'
 
 require 'scmd/command'
+require 'scmd/command_spy'
+require 'scmd/stored_commands'
 
 module Scmd
 
@@ -9,10 +11,91 @@ module Scmd
     desc "Scmd"
     subject{ Scmd }
 
-    should have_instance_method :new
+    should have_imeths :new, :commands, :calls, :reset, :add_command
+
+  end
+
+  class NonTestModeTests < UnitTests
+    desc "when NOT in test mode"
 
     should "build a `Command` with the `new` method" do
-      assert_kind_of Scmd::Command, subject.new('echo hi')
+      assert_instance_of Scmd::Command, subject.new('echo hi')
+    end
+
+    should "raise no method error on the test mode API methods" do
+      [:commands, :calls, :reset].each do |meth|
+        assert_raises(NoMethodError) do
+          subject.send(meth)
+        end
+      end
+      assert_raises(NoMethodError) do
+        subject.add_command(Factory.string)
+      end
+    end
+
+  end
+
+  class TestModeTests < UnitTests
+    desc "when in test mode"
+    setup do
+      @orig_scmd_test_mode = ENV['SCMD_TEST_MODE']
+      ENV['SCMD_TEST_MODE'] = '1'
+      Scmd.reset
+    end
+    teardown do
+      Scmd.reset
+      ENV['SCMD_TEST_MODE'] = @orig_scmd_test_mode
+    end
+
+    should "get a command spy from the commands collection with the new` method" do
+      assert_equal Scmd::CommandSpy.new('echo hi'), subject.new('echo hi')
+    end
+
+    should "know its test mode API attrs" do
+      assert_equal StoredCommands.new, subject.commands
+      assert_equal [],                 subject.calls
+    end
+
+    should "clear/remove the test mode API attrs on `reset`" do
+      cmd_str = Factory.string
+      subject.commands.add(cmd_str)
+      subject.calls.push(cmd_str)
+      assert_not_empty subject.commands
+      assert_not_empty subject.calls
+
+      subject.reset
+      assert_empty subject.commands
+      assert_empty subject.calls
+    end
+
+    should "add stored commands using `add_command`" do
+      cmd_str = Factory.string
+      output  = Factory.text
+      assert_not_equal output, subject.new(cmd_str).stdout
+
+      subject.add_command(cmd_str){ |cmd| cmd.stdout = output }
+      assert_equal output, subject.new(cmd_str).stdout
+    end
+
+  end
+
+  class CallTests < UnitTests
+    desc "Call"
+    setup do
+      @cmd_str = Factory.string
+      @input   = Factory.text
+      @cmd     = CommandSpy.new(@cmd_str)
+
+      @call = Call.new(@cmd, @input)
+    end
+    subject{ @call }
+
+    should have_accessors :cmd_str, :input, :cmd
+
+    should "know its attrs" do
+      assert_equal @cmd_str, subject.cmd_str
+      assert_equal @input,   subject.input
+      assert_equal @cmd,     subject.cmd
     end
 
   end

data/test/unit/stored_commands_tests.rb

@@ -0,0 +1,146 @@
+require 'assert'
+require 'scmd/stored_commands'
+
+require 'scmd/command_spy'
+
+class Scmd::StoredCommands
+
+  class UnitTests < Assert::Context
+    desc "Scmd::StoredCommands"
+    setup do
+      @cmd_str = Factory.string
+      @opts    = { Factory.string => Factory.string }
+      @output  = Factory.text
+
+      @commands = Scmd::StoredCommands.new
+    end
+    subject{ @commands }
+
+    should have_imeths :add, :get, :remove, :remove_all, :empty?
+
+    should "allow adding and getting commands when yielded a command" do
+      yielded = nil
+      subject.add(@cmd_str) do |cmd|
+        yielded = cmd
+        cmd.stdout = @output
+      end
+      cmd_spy = subject.get(@cmd_str, {})
+
+      assert_instance_of Scmd::CommandSpy, yielded
+      assert_equal yielded, cmd_spy
+      assert_equal @output, cmd_spy.stdout
+    end
+
+    should "return a stub when adding a command" do
+      stub = subject.add(@cmd_str)
+      assert_instance_of Scmd::StoredCommands::Stub, stub
+
+      stub.with(@opts){ |cmd| cmd.stdout = @output }
+      cmd = subject.get(@cmd_str, @opts)
+      assert_equal @output, cmd.stdout
+
+      cmd = subject.get(@cmd_str, {})
+      assert_not_equal @output, cmd.stdout
+    end
+
+    should "return a unaltered cmd spy for a cmd str that isn't configured" do
+      cmd_spy = Scmd::CommandSpy.new(@cmd_str)
+      cmd = subject.get(@cmd_str)
+
+      assert_equal cmd_spy, cmd
+    end
+
+    should "not call a cmd block until it is retrieved" do
+      called = false
+      subject.add(@cmd_str){ called = true }
+      assert_false called
+      subject.get(@cmd_str)
+      assert_true called
+    end
+
+    should "allow removing a stub" do
+      subject.add(@cmd_str){ |cmd| cmd.stdout = @output }
+      cmd = subject.get(@cmd_str)
+      assert_equal @output, cmd.stdout
+
+      subject.remove(@cmd_str)
+      cmd = subject.get(@cmd_str)
+      assert_not_equal @output, cmd.stdout
+    end
+
+    should "allow removing all commands" do
+      subject.add(@cmd_str){ |cmd| cmd.stdout = @output }
+      other_cmd_str = Factory.string
+      subject.add(other_cmd_str){ |cmd| cmd.stdout = @output }
+
+      subject.remove_all
+      cmd = subject.get(@cmd_str)
+      assert_not_equal @output, cmd.stdout
+      cmd = subject.get(other_cmd_str)
+      assert_not_equal @output, cmd.stdout
+    end
+
+    should "know if it is empty or not" do
+      assert_empty subject
+
+      subject.add(@cmd_str)
+      assert_not_empty subject
+
+      subject.remove_all
+      assert_empty subject
+    end
+
+    should "know if it is equal to another stored commands or not" do
+      cmds1 = Scmd::StoredCommands.new
+      cmds2 = Scmd::StoredCommands.new
+      assert_equal cmds1, cmds2
+
+      cmds1.add(@cmd_str)
+      assert_not_equal cmds1, cmds2
+    end
+
+  end
+
+  class StubTests < UnitTests
+    desc "Stub"
+    setup do
+      @stub = Stub.new(@cmd_str)
+    end
+    subject{ @stub }
+
+    should have_readers :cmd_str, :hash
+    should have_imeths :set_default_proc, :with, :call
+
+    should "default its default command proc" do
+      cmd_spy = Scmd::CommandSpy.new(@cmd_str, @opts)
+      cmd = subject.call(@opts)
+      assert_equal cmd_spy, cmd
+    end
+
+    should "allow setting its default proc" do
+      subject.set_default_proc{ |cmd| cmd.stdout = @output }
+      cmd = subject.call(@opts)
+      assert_equal @output, cmd.stdout
+    end
+
+    should "allow setting commands for specific opts" do
+      cmd = subject.call(@opts)
+      assert_equal '', cmd.stdout
+
+      subject.with({}){ |cmd| cmd.stdout = @output }
+      cmd = subject.call({})
+      assert_equal @output, cmd.stdout
+    end
+
+    should "know if it is equal to another stub or not" do
+      stub1 = Stub.new(@cmd_str)
+      stub2 = Stub.new(@cmd_str)
+      assert_equal stub1, stub2
+
+      Assert.stub(stub1, [:cmd_str, :hash].choice){ Factory.string }
+      assert_not_equal stub1, stub2
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: scmd
 version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: 
-  segments: 
-  - 3
-  - 0
-  - 0
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,38 +10,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-10-12 00:00:00 Z
+date: 2015-12-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 29
-        segments: 
-        - 2
-        - 15
         version: "2.15"
   type: :development
+  requirement: *id001
   name: assert
-  version_requirements: *id001
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 0
-        - 3
-        - 11
         version: 0.3.11
   type: :runtime
+  requirement: *id002
   name: posix-spawn
-  version_requirements: *id002
   prerelease: false
 description: Build and run system commands.
 email: 
@@ -69,54 +52,55 @@ files:
 - bench/runner.rb
 - lib/scmd.rb
 - lib/scmd/command.rb
+- lib/scmd/command_spy.rb
+- lib/scmd/stored_commands.rb
 - lib/scmd/version.rb
 - log/.gitkeep
 - scmd.gemspec
 - script/bench.rb
 - test/helper.rb
 - test/support/bigger-than-64k.txt
+- test/support/factory.rb
 - test/support/smaller-than-64k.txt
 - test/system/command_tests.rb
+- test/unit/command_spy_tests.rb
 - test/unit/command_tests.rb
 - test/unit/scmd_tests.rb
+- test/unit/stored_commands_tests.rb
 - tmp/.gitkeep
 homepage: http://github.com/redding/scmd
 licenses: 
 - MIT
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
+  - &id003 
+    - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id003
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Build and run system commands.
 test_files: 
 - test/helper.rb
 - test/support/bigger-than-64k.txt
+- test/support/factory.rb
 - test/support/smaller-than-64k.txt
 - test/system/command_tests.rb
+- test/unit/command_spy_tests.rb
 - test/unit/command_tests.rb
 - test/unit/scmd_tests.rb
+- test/unit/stored_commands_tests.rb