assert 2.15.1 → 2.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  data.tar.gz: 224cee40b0eced9582504764379f3f5dafae637c
-  metadata.gz: 5858e3f1715252601de72d47678dc9f215267254
 SHA512: 
-  data.tar.gz: 6b3d06c534eb907ae92c281b36de62967138bbc3788d536c92ad03b8d28d637dcf0ad0526fb66610dcc9b6cbc894a44e786c312bcfd6f93ae1ea29319f8aaf6f
-  metadata.gz: ed18f6eaea92fcec29d9b6b2200cb23704ad8b4090372493a81b67067b251176d71408231f8bc7e7c9de1a88c55cd854857d6fa153c67d79bf3a752b5fdb1df1
+  data.tar.gz: 87349e6848472856f049017257486230a2b69f52bcf4d5ebdf4d4a23f88dd5b479d1499890ea1c63e890186c4c86d665c982d162ebd86a51e07762b809029e26
+  metadata.gz: 539e868afc215555b585a85dd4caf52e9fbc7082e2eada2c33aea41900e22bb3a547c193b40f5433192bcd27571efd79254d93f54b7a973eab8fef0489398a55
+SHA1: 
+  data.tar.gz: fd4a2030e5b99394b4461d7673324e00fad58647
+  metadata.gz: bb7bf7dd4fb2b739e897932d9499487ac730e1fc

data/README.md

@@ -89,6 +89,8 @@ myobj.mymeth(123)
   # => StubError: arity mismatch
 Assert.stub(myobj, :mymeth).with(123){ 'stub-meth' }
   # => StubError: arity mismatch
+Assert.stub_send(myobj, :mymeth) # call to the original method post-stub
+  # => 'meth'
 
 Assert.stub(myobj, :myval){ 'stub-meth' }
   # => StubError: arity mismatch
@@ -99,6 +101,10 @@ myobj.myval(123)
   # => '123'
 myobj.myval(456)
   # => StubError: `myval(456)` not stubbed.
+Assert.stub_send(myobj, :myval, 123) # call to the original method post-stub
+  # => 123
+Assert.stub_send(myobj, :myval, 456)
+  # => 456
 
 Assert.unstub(myobj, :mymeth)
 Assert.unstub(myobj, :myval)

data/lib/assert/assert_runner.rb

@@ -10,7 +10,7 @@ module Assert
 
     def initialize(config, test_paths, test_options)
       @config = config
-      Assert::CLI.bench('Apply settings') do
+      Assert::CLI.bench('Applying settings') do
         apply_user_settings
         apply_local_settings
         apply_env_settings
@@ -25,7 +25,7 @@ module Assert
     def init(test_files, test_dir)
       # load any test helper file
       if test_dir && (h = File.join(test_dir, self.config.test_helper)) && File.exists?(h)
-        Assert::CLI.bench('Require test helper'){ require h }
+        Assert::CLI.bench('Requiring test helper'){ require h }
       end
 
       if self.config.list
@@ -38,7 +38,7 @@ module Assert
       runner.before_load(test_files)
       suite.before_load(test_files)
       view.before_load(test_files)
-      Assert::CLI.bench("Require #{test_files.size} test files") do
+      Assert::CLI.bench("Requiring #{test_files.size} test files") do
         test_files.each{ |p| require p }
       end
       if self.config.debug

data/lib/assert/cli.rb

@@ -11,16 +11,25 @@ module Assert
       args.include?('-d') || args.include?('--debug')
     end
 
-    def self.debug_msg(msg, time_in_ms = nil)
-      "[DEBUG] #{msg}#{" (#{time_in_ms} ms)" if time_in_ms}"
+    def self.debug_msg(msg)
+      "[DEBUG] #{msg}"
     end
 
-    def self.bench(msg, &block)
+    def self.debug_start_msg(msg)
+      debug_msg("#{msg}...".ljust(30))
+    end
+
+    def self.debug_finish_msg(time_in_ms)
+      " (#{time_in_ms} ms)"
+    end
+
+    def self.bench(start_msg, &block)
       if !Assert.config.debug
         block.call; return
       end
+      print debug_start_msg(start_msg)
       RoundedMillisecondTime.new(Benchmark.measure(&block).real).tap do |time_in_ms|
-        puts debug_msg(msg, time_in_ms)
+        puts debug_finish_msg(time_in_ms)
       end
     end
 

data/lib/assert/stub.rb

@@ -4,20 +4,30 @@ module Assert
     @stubs ||= {}
   end
 
-  def self.stub(*args, &block)
-    (self.stubs[Assert::Stub.key(*args)] ||= Assert::Stub.new(*args)).tap do |s|
-      s.do = block
-    end
+  def self.stub(obj, meth, &block)
+    (self.stubs[Assert::Stub.key(obj, meth)] ||= begin
+      orig_caller = caller
+      Assert::Stub.new(obj, meth, orig_caller)
+    end).tap{ |s| s.do = block }
   end
 
-  def self.unstub(*args)
-    (self.stubs.delete(Assert::Stub.key(*args)) || Assert::Stub::NullStub.new).teardown
+  def self.unstub(obj, meth)
+    (self.stubs.delete(Assert::Stub.key(obj, meth)) || Assert::Stub::NullStub.new).teardown
   end
 
   def self.unstub!
     self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
   end
 
+  def self.stub_send(obj, meth, *args, &block)
+    orig_caller = caller
+    stub = self.stubs.fetch(Assert::Stub.key(obj, meth)) do
+      msg = "`#{meth}` not stubbed"
+      raise NotStubbedError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+    end
+    stub.call_method(args, &block)
+  end
+
   StubError = Class.new(ArgumentError)
   NotStubbedError = Class.new(StubError)
   StubArityError = Class.new(StubError)
@@ -34,52 +44,53 @@ module Assert
 
     attr_reader :method_name, :name, :ivar_name, :do
 
-    def initialize(object, method_name, &block)
+    def initialize(object, method_name, orig_caller = nil, &block)
+      orig_caller ||= caller
       @metaclass = class << object; self; end
       @method_name = method_name.to_s
       @name = "__assert_stub__#{object.object_id}_#{@method_name}"
       @ivar_name = "@__assert_stub_#{object.object_id}_" \
                    "#{@method_name.to_sym.object_id}"
 
-      setup(object)
+      setup(object, orig_caller)
 
-      @do = block || Proc.new do |*args, &block|
-        err_msg = "#{inspect_call(args)} not stubbed."
-        inspect_lookup_stubs.tap do |stubs|
-          err_msg += "\nStubs:\n#{stubs}" if !stubs.empty?
-        end
-        raise NotStubbedError, err_msg
-      end
-      @lookup = Hash.new{ |hash, key| self.do }
+      @do     = block
+      @lookup = {}
+    end
+
+    def do=(block)
+      @do = block || @do
     end
 
-    def call(*args, &block)
+    def call_method(args, &block)
+      @method.call(*args, &block)
+    end
+
+    def call(args, orig_caller = nil, &block)
+      orig_caller ||= caller
       unless arity_matches?(args)
-        message = "arity mismatch on `#{@method_name}`: " \
-                  "expected #{number_of_args(@method.arity)}, " \
-                  "called with #{args.size}"
-        raise StubArityError, message
+        msg = "arity mismatch on `#{@method_name}`: " \
+              "expected #{number_of_args(@method.arity)}, " \
+              "called with #{args.size}"
+        raise StubArityError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
       end
-      @lookup[args].call(*args, &block)
+      lookup(args, orig_caller).call(*args, &block)
     rescue NotStubbedError => exception
       @lookup.rehash
-      @lookup[args].call(*args, &block)
+      lookup(args, orig_caller).call(*args, &block)
     end
 
     def with(*args, &block)
+      orig_caller = caller
       unless arity_matches?(args)
-        message = "arity mismatch on `#{@method_name}`: " \
-                  "expected #{number_of_args(@method.arity)}, " \
-                  "stubbed with #{args.size}"
-        raise StubArityError, message
+        msg = "arity mismatch on `#{@method_name}`: " \
+              "expected #{number_of_args(@method.arity)}, " \
+              "stubbed with #{args.size}"
+        raise StubArityError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
       end
       @lookup[args] = block
     end
 
-    def do=(block)
-      @do = block || @do
-    end
-
     def teardown
       @metaclass.send(:undef_method, @method_name)
       Assert.send(:remove_instance_variable, @ivar_name)
@@ -95,9 +106,10 @@ module Assert
 
     protected
 
-    def setup(object)
+    def setup(object, orig_caller)
       unless object.respond_to?(@method_name)
-        raise StubError, "#{object.inspect} does not respond to `#{@method_name}`"
+        msg = "#{object.inspect} does not respond to `#{@method_name}`"
+        raise StubError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
       end
       is_constant = object.kind_of?(Module)
       local_object_methods = object.methods(false).map(&:to_s)
@@ -118,13 +130,25 @@ module Assert
       Assert.instance_variable_set(@ivar_name, self)
       @metaclass.class_eval <<-stub_method
         def #{@method_name}(*args, &block)
-          Assert.instance_variable_get("#{@ivar_name}").call(*args, &block)
+          Assert.instance_variable_get("#{@ivar_name}").call(args, caller, &block)
         end
       stub_method
     end
 
     private
 
+    def lookup(args, orig_caller)
+      @lookup.fetch(args) do
+        self.do || begin
+          msg = "#{inspect_call(args)} not stubbed."
+          inspect_lookup_stubs.tap do |stubs|
+            msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+          end
+          raise NotStubbedError.new(msg).tap{ |e| e.set_backtrace(orig_caller) }
+        end
+      end
+    end
+
     def arity_matches?(args)
       return true if @method.arity == args.size # mandatory args
       return true if @method.arity < 0 && args.size >= (@method.arity+1).abs # variable args

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.15.1"
+  VERSION = "2.15.2"
 end

data/test/unit/assert_tests.rb

@@ -10,7 +10,7 @@ module Assert
     subject { Assert }
 
     should have_imeths :config, :configure, :view, :suite, :runner
-    should have_imeths :stubs, :stub, :unstub, :unstub!
+    should have_imeths :stubs, :stub, :unstub, :unstub!, :stub_send
 
     should "know its config instance" do
       assert_kind_of Assert::Config, subject.config
@@ -29,10 +29,14 @@ module Assert
 
   class StubTests < UnitTests
     setup do
+      @orig_value = Factory.string
+      @stub_value = Factory.string
+
       @myclass = Class.new do
-        def mymeth; 'meth'; end
+        def initialize(value); @value = value; end
+        def mymeth; @value; end
       end
-      @myobj = @myclass.new
+      @myobj = @myclass.new(@orig_value)
     end
 
     should "build a stub" do
@@ -49,31 +53,31 @@ module Assert
     should "set the stub's do block if given a block" do
       Assert.stub(@myobj, :mymeth)
       assert_raises(NotStubbedError){ @myobj.mymeth }
-      Assert.stub(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', @myobj.mymeth
+      Assert.stub(@myobj, :mymeth){ @stub_value }
+      assert_equal @stub_value, @myobj.mymeth
     end
 
     should "teardown stubs" do
-      assert_equal 'meth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
       Assert.unstub(@myobj, :mymeth)
-      assert_equal 'meth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
 
-      assert_equal 'meth', @myobj.mymeth
-      Assert.stub(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
+      Assert.stub(@myobj, :mymeth){ @stub_value }
+      assert_equal @stub_value, @myobj.mymeth
       Assert.unstub(@myobj, :mymeth)
-      assert_equal 'meth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
     end
 
     should "know and teardown all stubs" do
-      assert_equal 'meth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
 
-      Assert.stub(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', @myobj.mymeth
+      Assert.stub(@myobj, :mymeth){ @stub_value }
+      assert_equal @stub_value, @myobj.mymeth
       assert_equal 1, Assert.stubs.size
 
       Assert.unstub!
-      assert_equal 'meth', @myobj.mymeth
+      assert_equal @orig_value, @myobj.mymeth
       assert_empty Assert.stubs
     end
 
@@ -91,6 +95,15 @@ module Assert
       assert_empty Assert.stubs
     end
 
+    should "be able to call a stub's original method" do
+      assert_raises(NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
+
+      Assert.stub(@myobj, :mymeth){ @stub_value }
+
+      assert_equal @stub_value, @myobj.mymeth
+      assert_equal @orig_value, Assert.stub_send(@myobj, :mymeth)
+    end
+
   end
 
 end

data/test/unit/stub_tests.rb

@@ -24,6 +24,7 @@ class Assert::Stub
     should have_readers :method_name, :name, :ivar_name, :do
     should have_writers :do
     should have_cmeths :key
+    should have_imeths :call_method, :call, :with, :teardown
 
     should "generate a key given an object and method name" do
       obj = @myobj
@@ -41,9 +42,7 @@ class Assert::Stub
     end
 
     should "complain when called if no do block was given" do
-      assert_raises Assert::NotStubbedError do
-        @myobj.mymeth
-      end
+      assert_raises(Assert::NotStubbedError){ @myobj.mymeth }
 
       subject.do = proc{ 'mymeth' }
       assert_nothing_raised do
@@ -56,9 +55,7 @@ class Assert::Stub
     end
 
     should "complain if stubbing a method that the object doesn't respond to" do
-      assert_raises Assert::StubError do
-        Assert::Stub.new(@myobj, :some_other_meth)
-      end
+      assert_raises(Assert::StubError){ Assert::Stub.new(@myobj, :some_other_meth) }
     end
 
     should "complain if stubbed and called with no `do` proc given" do
@@ -187,6 +184,54 @@ class Assert::Stub
       assert_equal 'four-five-six', mydelegator.myvalargs(4,5,6)
     end
 
+    should "call to the original method" do
+      subject.teardown
+
+      # no args
+      stub = Assert::Stub.new(@myobj, :mymeth){ 'mymeth' }
+      assert_equal 'mymeth', stub.call([])
+      assert_equal 'meth',   stub.call_method([])
+
+      # static args
+      stub = Assert::Stub.new(@myobj, :myval){ |val| val.to_s }
+      assert_equal '1', stub.call([1])
+      assert_equal 1,   stub.call_method([1])
+      assert_equal '2', stub.call([2])
+      assert_equal 2,   stub.call_method([2])
+      stub.with(2){ 'two' }
+      assert_equal 'two', stub.call([2])
+      assert_equal 2,     stub.call_method([2])
+
+      # dynamic args
+      stub = Assert::Stub.new(@myobj, :myargs){ |*args| args.join(',') }
+      assert_equal '1,2',   stub.call([1,2])
+      assert_equal [1,2],   stub.call_method([1,2])
+      assert_equal '3,4,5', stub.call([3,4,5])
+      assert_equal [3,4,5], stub.call_method([3,4,5])
+      stub.with(3,4,5){ 'three-four-five' }
+      assert_equal 'three-four-five', stub.call([3,4,5])
+      assert_equal [3,4,5],           stub.call_method([3,4,5])
+
+      # mixed static/dynamic args
+      stub = Assert::Stub.new(@myobj, :myvalargs){ |*args| args.join(',') }
+      assert_equal '1,2,3',    stub.call([1,2,3])
+      assert_equal [1,2, [3]], stub.call_method([1,2,3])
+      assert_equal '3,4,5',    stub.call([3,4,5])
+      assert_equal [3,4,[5]],  stub.call_method([3,4,5])
+      stub.with(3,4,5){ 'three-four-five' }
+      assert_equal 'three-four-five', stub.call([3,4,5])
+      assert_equal [3,4,[5]],         stub.call_method([3,4,5])
+
+      # blocks
+      blkcalled = false
+      blk = proc{ blkcalled = true }
+      stub = Assert::Stub.new(@myobj, :myblk){ blkcalled = 'true' }
+      stub.call([], &blk)
+      assert_equal 'true', blkcalled
+      stub.call_method([], &blk)
+      assert_equal true, blkcalled
+    end
+
     should "store and remove itself on asserts main module" do
       assert_equal subject, Assert.instance_variable_get(subject.ivar_name)
       subject.teardown
@@ -222,7 +267,7 @@ class Assert::Stub
     subject{ @stub }
 
     should "not raise a stub error when called" do
-      assert_nothing_raised{ @stub.call(@arg) }
+      assert_nothing_raised{ @stub.call([@arg]) }
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  version: 2.15.1
+  version: 2.15.2
 platform: ruby
 authors: 
 - Kelly Redding
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2016-03-29 00:00:00 Z
+date: 2016-04-13 00:00:00 Z
 dependencies: []
 
 description: Assertion style testing framework.