rr 0.10.5 → 0.10.6

data/CHANGES

@@ -1,3 +1,8 @@
+- Added MIT license
+- Fixed Bug - dont_allow doesn't work when it follows stub (http://github.com/btakita/rr/issues#issue/20)
+- Fixed exception with DoubleInjections on proxy objects (http://github.com/btakita/rr/issues#issue/24)
+- Fixed Bug - Can't stub attribute methods on a BelongsToAssociation (http://github.com/btakita/rr/issues#issue/24)
+
 0.10.5
 - Fixed issues with Ruby 1.9
 - Fixed stack overflow caused by double include in Test::Unit adapter [http://github.com/btakita/rr/issues#issue/16]. Identified by Dave Myron (http://github.com/contentfree)

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Brian Takita
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -327,8 +327,8 @@ RR::WildcardMatchers for details.
   mock(object).method_name(anything).times(any_times) {return_value}
 
 == Special Thanks To
-With any development effort, there are countless people who have contributed
-to making it possible. We all are standing on the shoulders of giants.
+With any development effort, there are countless people who have contributed to making it possible. We all are standing on the shoulders of giants.
+If you have directly contributed to RR and I missed you in this list, please let me know and I will add you. Thanks!
 * Andreas Haller for patches
 * Aslak Hellesoy for Developing Rspec
 * Bryan Helmkamp for patches
@@ -347,9 +347,11 @@ to making it possible. We all are standing on the shoulders of giants.
 * Matthew O'Connor for patches and pairing with me
 * Michael Niessner for patches and pairing with me
 * Mike Mangino (from Elevated Rails) for patches and pairing with me
+* Myron Marston for bug reports
 * Nick Kallen for documentation suggestions, bug reports, and patches
 * Nathan Sobo for various ideas and inspiration for cleaner and more expressive code
 * Parker Thompson for pairing with me
 * Phil Darnowsky for patches
 * Pivotal Labs for sponsoring RR development
 * Stephen Baker for Developing Rspec
+* Tatsuya Ono for patches

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:patch: 5
 :build: 
-:major: 0
 :minor: 10
+:patch: 6
+:major: 0

data/lib/rr.rb

@@ -64,6 +64,7 @@ require "#{dir}/rr/wildcard_matchers/hash_including"
 require "#{dir}/rr/times_called_matchers/terminal"
 require "#{dir}/rr/times_called_matchers/non_terminal"
 require "#{dir}/rr/times_called_matchers/times_called_matcher"
+require "#{dir}/rr/times_called_matchers/never_matcher"
 require "#{dir}/rr/times_called_matchers/any_times_matcher"
 require "#{dir}/rr/times_called_matchers/integer_matcher"
 require "#{dir}/rr/times_called_matchers/range_matcher"

data/lib/rr/double_definitions/double_definition.rb

@@ -97,7 +97,7 @@ module RR
         #
         #   mock(subject).method_name.never
         def never
-          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(0)
+          @times_matcher = TimesCalledMatchers::NeverMatcher.new
           self
         end
 

data/lib/rr/double_definitions/strategies/strategy.rb

@@ -21,7 +21,7 @@ module RR
             end
           end
 
-          def register_self_at_double_definition_creator
+          def register_self_at_double_definition_creator(domain_name)
           end
         end
 

data/lib/rr/double_definitions/strategies/verification/dont_allow.rb

@@ -25,7 +25,6 @@ module RR
           def do_call
             definition.never
             permissive_argument
-            reimplementation
           end
         end
       end

data/lib/rr/double_matches.rb

@@ -19,33 +19,24 @@ module RR
         if double.exact_match?(*args)
           matching_doubles << double
           if double.attempt?
-            exact_double_is_terminal_or_non_terminal double
+            if double.terminal?
+              exact_terminal_doubles_to_attempt << double
+            else
+              exact_non_terminal_doubles_to_attempt << double
+            end
           end
         elsif double.wildcard_match?(*args)
           matching_doubles << double
           if double.attempt?
-            wildcard_double_is_terminal_or_non_terminal double
+            if double.terminal?
+              wildcard_terminal_doubles_to_attempt << double
+            else
+              wildcard_non_terminal_doubles_to_attempt << double
+            end
           end
         end
       end
       self
     end
-
-    protected
-    def exact_double_is_terminal_or_non_terminal(double)
-      if double.terminal?
-        exact_terminal_doubles_to_attempt << double
-      else
-        exact_non_terminal_doubles_to_attempt << double
-      end
-    end
-
-    def wildcard_double_is_terminal_or_non_terminal(double)
-      if double.terminal?
-        wildcard_terminal_doubles_to_attempt << double
-      else
-        wildcard_non_terminal_doubles_to_attempt << double
-      end
-    end
   end
 end

data/lib/rr/injections/double_injection.rb

@@ -28,7 +28,11 @@ module RR
       def bind
         if subject_respond_to_method?(method_name)
           if subject_has_method_defined?(method_name)
-            bind_method_with_alias
+            if subject_is_proxy_for_method?(method_name)
+              bind_method
+            else
+              bind_method_with_alias
+            end
           else
             space.method_missing_injection(subject)
             space.singleton_method_added_injection(subject)
@@ -95,6 +99,11 @@ module RR
       end
 
       protected
+      def subject_is_proxy_for_method?(method_name)
+        method_owner = @subject.method(method_name).owner
+        !(subject_class.object_id == method_owner.object_id || subject_class.ancestors.include?(method_owner))
+      end
+
       def deferred_bind_method
         unless subject_has_method_defined?(original_method_alias_name)
           bind_method_with_alias
@@ -108,13 +117,13 @@ module RR
       end
 
       def bind_method
-        returns_method = <<-METHOD
+        subject = @subject.is_a?(Class) && !@subject.name.empty? ? @subject.name : "self"
+        subject_class.class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
         def #{@method_name}(*args, &block)
           arguments = MethodArguments.new(args, block)
-          RR::Space.double_injection(self, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
+          RR::Space.double_injection(#{subject}, :#{@method_name}).dispatch_method(arguments.arguments, arguments.block)
         end
         METHOD
-        subject_class.class_eval(returns_method, __FILE__, __LINE__ - 5)
       end
     end
   end

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -12,11 +12,12 @@ module RR
         if double
           double.method_call(args)
           call_yields
-          return_value = extract_subject_from_return_value(call_implementation)
+          return_value_1 = call_implementation
+          return_value_2 = extract_subject_from_return_value(return_value_1)
           if after_call_proc
-            extract_subject_from_return_value(after_call_proc.call(return_value))
+            extract_subject_from_return_value(after_call_proc.call(return_value_2))
           else
-            return_value
+            return_value_2
           end
         else
           double_not_found_error

data/lib/rr/times_called_matchers/never_matcher.rb

@@ -0,0 +1,23 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class NeverMatcher < TimesCalledMatcher
+      include Terminal
+
+      def initialize
+        super 0
+      end
+
+      def possible_match?(times_called)
+        true
+      end
+
+      def matches?(times_called)
+        true
+      end
+
+      def attempt?(times_called)
+        raise RR::Errors::TimesCalledError, error_message(1)
+      end
+    end
+  end
+end

data/spec/api/dont_allow/dont_allow_after_stub_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "dont_allow called after stub" do
+  context "when the subject method is called" do
+    it "raises a TimesCalledError" do
+      subject = Object.new
+      stub(subject).foobar
+      dont_allow(subject).foobar
+      lambda do
+        subject.foobar
+      end.should raise_error(RR::Errors::TimesCalledError)
+    end
+  end
+end

data/spec/api/mock/mock_spec.rb

@@ -0,0 +1,183 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "mock" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "mocks via inline call" do
+    mock(subject).to_s {"a value"}
+    subject.to_s.should == "a value"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      mock(subject).to_s {"value 1"}.ordered
+      mock(subject).to_s {"value 2"}.twice
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 2"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      proxy.methods.should =~ proxy_target.methods
+
+      mock(proxy).foobar {:new_foobar}
+      proxy.foobar.should == :new_foobar
+    end
+  end
+
+  it 'allows terse chaining' do
+    mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
+    subject.first(1).second(2).third(3).should == 4
+  end
+
+  it 'allows chaining with proxy' do
+    find_return_value = Object.new
+    def find_return_value.child
+      :the_child
+    end
+    (class << subject; self; end).class_eval do
+      define_method(:find) do |id|
+        id == '1' ? find_return_value : raise(ArgumentError)
+      end
+    end
+
+    mock.proxy(subject).find('1').mock.proxy!.child
+    subject.find('1').child.should == :the_child
+  end
+
+  it 'allows branched chaining' do
+    mock(subject).first do
+      mock! do |expect|
+        expect.branch1 {mock!.branch11 {11}}
+        expect.branch2 {mock!.branch22 {22}}
+      end
+    end
+    o = subject.first
+    o.branch1.branch11.should == 11
+    o.branch2.branch22.should == 22
+  end
+
+  it 'allows chained ordering' do
+    mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
+    subject.to_s.should == "value 1"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 3"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "mocks via block with argument" do
+    mock subject do |c|
+      c.to_s {"a value"}
+      c.to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "mocks via block without argument" do
+    mock subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "has wildcard matchers" do
+    mock(subject).foobar(
+      is_a(String),
+      anything,
+      numeric,
+      boolean,
+      duck_type(:to_s),
+      /abc/
+    ) {"value 1"}.twice
+    subject.foobar(
+      'hello',
+      Object.new,
+      99,
+      false,
+      "My String",
+      "Tabcola"
+    ).should == "value 1"
+    lambda do
+      subject.foobar(:failure)
+    end.should raise_error( RR::Errors::DoubleNotFoundError )
+  end
+
+  it "mocks methods without letters" do
+    mock(subject) == 55
+
+    subject == 55
+    lambda do
+      subject == 99
+    end.should raise_error(RR::Errors::DoubleNotFoundError)
+  end
+
+  describe "on class method" do
+    class SampleClass1
+      def self.hello; "hello!"; end
+    end
+
+    class SampleClass2 < SampleClass1; end
+
+    it "can mock" do
+      mock(SampleClass1).hello { "hola!" }
+
+      SampleClass1.hello.should == "hola!"
+    end
+
+    it "should not break when it is mocked on subclass" do
+      mock(SampleClass1).hello { "hi!" }
+
+      SampleClass2.hello.should == "hi!"
+    end
+
+    it "should not get affected from a previous example" do
+      SampleClass2.hello.should == "hello!"
+    end
+
+  end
+end

data/spec/api/proxy/proxy_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "proxy" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "proxies via inline call" do
+    expected_to_s_value = subject.to_s
+    mock.proxy(subject).to_s
+    subject.to_s.should == expected_to_s_value
+    lambda {subject.to_s}.should raise_error
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    subject.to_s(:foo).should == "Original to_s with arg foo"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    subject.to_s(:foo).should == "Original to_s with arg foo"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "proxies via block with argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do |c|
+      c.foobar_1(1)
+      c.foobar_2
+    end
+    subject.foobar_1(1).should == :original_value_1
+    lambda {subject.foobar_1(:blah)}.should raise_error
+
+    subject.foobar_2.should == :original_value_2
+    lambda {subject.foobar_2(:blah)}.should raise_error
+  end
+
+  it "proxies via block without argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do
+      foobar_1(1)
+      foobar_2
+    end
+    subject.foobar_1(1).should == :original_value_1
+    lambda {subject.foobar_1(:blah)}.should raise_error
+
+    subject.foobar_2.should == :original_value_2
+    lambda {subject.foobar_2(:blah)}.should raise_error
+  end
+end

data/spec/api/spy/spy_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "spy" do
+  attr_reader :subject
+    before(:each) do
+      @subject = Object.new
+      extend RR::Adapters::RRMethods
+    end
+
+    after(:each) do
+      RR.reset
+    end
+
+  it "should record all method invocations" do
+    subject = Object.new
+    def subject.something
+    end
+
+    def subject.something_else
+    end
+
+    spy(subject)
+
+    subject.something
+    subject.something_else
+    subject.to_s
+
+    received(subject).something.call
+    received(subject).something_else.call
+    received(subject).to_s.call
+  end
+
+  describe "RR recorded_calls" do
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      subject.pig_rabbit("bacon", "bunny meat")
+      #subject.should have_received.pig_rabitt("bacon", "bunny meat")
+      received(subject).pig_rabbit("bacon", "bunny meat").call
+    end
+
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      lambda do
+        received(subject).pig_rabbit("bacon", "bunny meat").call
+      end.should raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
+    end
+  end  
+end

data/spec/api/strong/strong_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+class StrongSpecFixture
+  def method_with_no_arguments
+  end
+
+  def method_with_one_argument(string)
+  end
+
+  def method_with_two_arguments(string, integer)
+  end
+
+  def method_with_three_arguments_including_varargs(string, integer, *args)
+  end
+
+  def method_with_varargs(*args)
+  end
+end
+
+describe "strong" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  context "when the method does not exist" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).something
+      end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when the method exists with no arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_no_arguments
+    end
+  end
+
+  context "when the method has a different arity" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).method_with_one_argument
+      end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the method has accepts a variable number of arguments" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_varargs
+    end
+  end
+
+  context "when the method does not provide the required parameters before varargs" do
+    it "raises an exception" do
+      lambda do
+        strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs
+      end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+    end
+  end
+
+  context "when the minimum number of parameters are provided" do
+    it "does not raise an exception" do
+      strong.stub(StrongSpecFixture.new).method_with_three_arguments_including_varargs("one", 2)
+    end
+  end
+
+  context "when using instance_of and the method does not exist" do
+    it "raises an exception" do
+      lambda do
+        strong.stub.instance_of(StrongSpecFixture).something
+        StrongSpecFixture.new
+      end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+    end
+  end
+
+  context "when using instance_of and the method does exist" do
+    it "does not raise an exception" do
+      strong.stub.instance_of(StrongSpecFixture).method_with_no_arguments
+    end
+  end
+end

data/spec/api/stub/stub_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+class StubSpecFixture
+  attr_reader :initialize_arguments
+
+  def initialize(*args)
+    @initialize_arguments = args
+    yield if block_given?
+    method_run_in_initialize
+  end
+
+  def method_run_in_initialize
+
+  end
+end
+
+describe "stub" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "stubs via inline call" do
+    stub(subject).to_s {"a value"}
+    subject.to_s.should == "a value"
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      stub(subject).to_s {"value 1"}.once.ordered
+      stub(subject).to_s {"value 2"}.once.ordered
+
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      proxy.methods.should =~ proxy_target.methods
+
+      stub(proxy).foobar {:new_foobar}
+      proxy.foobar.should == :new_foobar
+    end
+  end
+
+  it "stubs via block with argument" do
+    stub subject do |d|
+      d.to_s {"a value"}
+      d.to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "stubs via block without argument" do
+    stub subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "stubs instance_of" do
+    stub.instance_of(StubSpecFixture) do |o|
+      o.to_s {"High Level Spec"}
+    end
+    StubSpecFixture.new.to_s.should == "High Level Spec"
+  end
+
+  it "stubs methods without letters" do
+    stub(subject).__send__(:==) {:equality}
+    (subject == 55).should == :equality
+  end
+
+  it "stubs methods invoked in #initialize while passing along the #initialize arg" do
+    method_run_in_initialize_stubbed = false
+    stub.instance_of(StubSpecFixture) do |o|
+      o.method_run_in_initialize {method_run_in_initialize_stubbed = true}
+    end
+    StubSpecFixture.new
+    method_run_in_initialize_stubbed.should be_true
+  end
+
+  it "passed the arguments and block passed to #initialize" do
+    block_called = false
+    stub.instance_of(StubSpecFixture) do |o|
+      o.method_run_in_initialize
+    end
+    instance = StubSpecFixture.new(1, 2) {block_called = true}
+    instance.initialize_arguments.should == [1, 2]
+    block_called.should be_true
+  end
+
+  context "mock then stub" do
+    it "stubs any calls not matching the mock" do
+      mock(subject).foobar(3) {:baz3}
+      stub(subject).foobar {:baz}
+      subject.foobar(3).should == :baz3
+      subject.foobar(4).should == :baz
+    end
+  end
+end

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -81,7 +81,7 @@ module RR
           context "when passed a method_name argument_expectation" do
             it "creates a mock Double for method" do
               double_definition = dont_allow(subject, :foobar)
-              double_definition.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+              double_definition.times_matcher.should == TimesCalledMatchers::NeverMatcher.new
               double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
               lambda do

data/spec/rr/double_definitions/double_definition_creator_spec.rb

@@ -111,7 +111,7 @@ module RR
             context "when passed a subject and a method_name argument_expectation" do
               it "creates a mock Double for method" do
                 double_definition = creator.dont_allow(subject, :foobar)
-                double_definition.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+                double_definition.times_matcher.should == TimesCalledMatchers::NeverMatcher.new
                 double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
                 lambda do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.10.5
+  version: 0.10.6
 platform: ruby
 authors: 
 - Brian Takita
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-20 00:00:00 -08:00
+date: 2010-02-15 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - CHANGES
+- LICENSE
 - README.rdoc
 - Rakefile
 - VERSION.yml
@@ -80,6 +81,7 @@ files:
 - lib/rr/times_called_matchers/at_least_matcher.rb
 - lib/rr/times_called_matchers/at_most_matcher.rb
 - lib/rr/times_called_matchers/integer_matcher.rb
+- lib/rr/times_called_matchers/never_matcher.rb
 - lib/rr/times_called_matchers/non_terminal.rb
 - lib/rr/times_called_matchers/proc_matcher.rb
 - lib/rr/times_called_matchers/range_matcher.rb
@@ -96,9 +98,14 @@ files:
 - lib/rr/wildcard_matchers/regexp.rb
 - lib/rr/wildcard_matchers/satisfy.rb
 - ruby_19_spec.rb
+- spec/api/dont_allow/dont_allow_after_stub_spec.rb
+- spec/api/mock/mock_spec.rb
+- spec/api/proxy/proxy_spec.rb
+- spec/api/spy/spy_spec.rb
+- spec/api/strong/strong_spec.rb
+- spec/api/stub/stub_spec.rb
 - spec/core_spec_suite.rb
 - spec/environment_fixture_setup.rb
-- spec/high_level_spec.rb
 - spec/proc_from_block_spec.rb
 - spec/rr/adapters/rr_methods_argument_matcher_spec.rb
 - spec/rr/adapters/rr_methods_creator_spec.rb
@@ -192,6 +199,5 @@ specification_version: 3
 summary: RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html
 test_files: 
 - spec/spy_verification_spec.rb
-- spec/high_level_spec.rb
 - spec/rr_spec.rb
 - spec/proc_from_block_spec.rb

data/spec/high_level_spec.rb

@@ -1,398 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
-
-class HighLevelSpec
-  attr_reader :initialize_arguments
-
-  def initialize(*args)
-    @initialize_arguments = args
-    yield if block_given?
-    method_run_in_initialize
-  end
-
-  def method_run_in_initialize
-    
-  end
-end
-
-describe "RR" do
-  attr_reader :subject
-  before(:each) do
-    @subject = Object.new
-    extend RR::Adapters::RRMethods
-  end
-
-  after(:each) do
-    RR.reset
-  end
-
-  describe "mock" do
-    it "mocks via inline call" do
-      mock(subject).to_s {"a value"}
-      subject.to_s.should == "a value"
-      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
-    end
-
-    it "allows ordering" do
-      mock(subject).to_s {"value 1"}.ordered
-      mock(subject).to_s {"value 2"}.twice
-      subject.to_s.should == "value 1"
-      subject.to_s.should == "value 2"
-      subject.to_s.should == "value 2"
-      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
-    end
-
-    it 'allows terse chaining' do
-      mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
-      subject.first(1).second(2).third(3).should == 4
-
-      mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
-      subject.first(1).second(2).third(3).should == 4
-
-      mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
-      subject.first(1).second(2).third(3).should == 4
-
-      mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
-      subject.first(1).second(2).third(3).should == 4
-
-      mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
-      subject.first(1).second(2).third(3).should == 4
-    end
-
-    it 'allows chaining with proxy' do
-      find_return_value = Object.new
-      def find_return_value.child
-        :the_child
-      end
-      (class << subject; self; end).class_eval do
-        define_method(:find) do |id|
-          id == '1' ? find_return_value : raise(ArgumentError)
-        end
-      end
-
-      mock.proxy(subject).find('1').mock.proxy!.child
-      subject.find('1').child.should == :the_child
-    end
-
-    it 'allows branched chaining' do
-      mock(subject).first do
-        mock! do |expect|
-          expect.branch1 {mock!.branch11 {11}}
-          expect.branch2 {mock!.branch22 {22}}
-        end
-      end
-      o = subject.first
-      o.branch1.branch11.should == 11
-      o.branch2.branch22.should == 22
-    end
-
-    it 'allows chained ordering' do
-      mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
-      subject.to_s.should == "value 1"
-      subject.to_s.should == "value 2"
-      subject.to_s.should == "value 2"
-      subject.to_s.should == "value 3"
-      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
-    end
-
-    it "mocks via block with argument" do
-      mock subject do |c|
-        c.to_s {"a value"}
-        c.to_sym {:crazy}
-      end
-      subject.to_s.should == "a value"
-      subject.to_sym.should == :crazy
-    end
-
-    it "mocks via block without argument" do
-      mock subject do
-        to_s {"a value"}
-        to_sym {:crazy}
-      end
-      subject.to_s.should == "a value"
-      subject.to_sym.should == :crazy
-    end
-
-    it "has wildcard matchers" do
-      mock(subject).foobar(
-        is_a(String),
-        anything,
-        numeric,
-        boolean,
-        duck_type(:to_s),
-        /abc/
-      ) {"value 1"}.twice
-      subject.foobar(
-        'hello',
-        Object.new,
-        99,
-        false,
-        "My String",
-        "Tabcola"
-      ).should == "value 1"
-      lambda do
-        subject.foobar(:failure)
-      end.should raise_error( RR::Errors::DoubleNotFoundError )
-    end
-
-    it "mocks methods without letters" do
-      mock(subject) == 55
-
-      subject == 55
-      lambda do
-        subject == 99
-      end.should raise_error(RR::Errors::DoubleNotFoundError)
-    end
-  end
-
-  describe "proxy" do
-    it "proxies via inline call" do
-      expected_to_s_value = subject.to_s
-      mock.proxy(subject).to_s
-      subject.to_s.should == expected_to_s_value
-      lambda {subject.to_s}.should raise_error
-    end
-
-    it "proxy allows ordering" do
-      def subject.to_s(arg)
-        "Original to_s with arg #{arg}"
-      end
-      mock.proxy(subject).to_s(:foo).ordered
-      mock.proxy(subject).to_s(:bar).twice.ordered
-
-      subject.to_s(:foo).should == "Original to_s with arg foo"
-      subject.to_s(:bar).should == "Original to_s with arg bar"
-      subject.to_s(:bar).should == "Original to_s with arg bar"
-      lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
-    end
-
-    it "proxy allows ordering" do
-      def subject.to_s(arg)
-        "Original to_s with arg #{arg}"
-      end
-      mock.proxy(subject).to_s(:foo).ordered
-      mock.proxy(subject).to_s(:bar).twice.ordered
-
-      subject.to_s(:foo).should == "Original to_s with arg foo"
-      subject.to_s(:bar).should == "Original to_s with arg bar"
-      subject.to_s(:bar).should == "Original to_s with arg bar"
-      lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
-    end
-
-    it "proxies via block with argument" do
-      def subject.foobar_1(*args)
-        :original_value_1
-      end
-
-      def subject.foobar_2
-        :original_value_2
-      end
-
-      mock.proxy subject do |c|
-        c.foobar_1(1)
-        c.foobar_2
-      end
-      subject.foobar_1(1).should == :original_value_1
-      lambda {subject.foobar_1(:blah)}.should raise_error
-
-      subject.foobar_2.should == :original_value_2
-      lambda {subject.foobar_2(:blah)}.should raise_error
-    end
-
-    it "proxies via block without argument" do
-      def subject.foobar_1(*args)
-        :original_value_1
-      end
-
-      def subject.foobar_2
-        :original_value_2
-      end
-
-      mock.proxy subject do
-        foobar_1(1)
-        foobar_2
-      end
-      subject.foobar_1(1).should == :original_value_1
-      lambda {subject.foobar_1(:blah)}.should raise_error
-
-      subject.foobar_2.should == :original_value_2
-      lambda {subject.foobar_2(:blah)}.should raise_error
-    end
-  end
-
-  describe "stub" do
-    it "stubs via inline call" do
-      stub(subject).to_s {"a value"}
-      subject.to_s.should == "a value"
-    end
-
-    it "allows ordering" do
-      stub(subject).to_s {"value 1"}.once.ordered
-      stub(subject).to_s {"value 2"}.once.ordered
-
-      subject.to_s.should == "value 1"
-      subject.to_s.should == "value 2"
-    end
-
-    it "stubs via block with argument" do
-      stub subject do |d|
-        d.to_s {"a value"}
-        d.to_sym {:crazy}
-      end
-      subject.to_s.should == "a value"
-      subject.to_sym.should == :crazy
-    end
-
-    it "stubs via block without argument" do
-      stub subject do
-        to_s {"a value"}
-        to_sym {:crazy}
-      end
-      subject.to_s.should == "a value"
-      subject.to_sym.should == :crazy
-    end
-
-    it "stubs instance_of" do
-      stub.instance_of(HighLevelSpec) do |o|
-        o.to_s {"High Level Spec"}
-      end
-      HighLevelSpec.new.to_s.should == "High Level Spec"
-    end
-
-    it "stubs methods without letters" do
-      stub(subject).__send__(:==) {:equality}
-      (subject == 55).should == :equality
-    end
-
-    it "stubs methods invoked in #initialize while passing along the #initialize arg" do
-      method_run_in_initialize_stubbed = false
-      stub.instance_of(HighLevelSpec) do |o|
-        o.method_run_in_initialize {method_run_in_initialize_stubbed = true}
-      end
-      HighLevelSpec.new
-      method_run_in_initialize_stubbed.should be_true
-    end
-
-    it "passed the arguments and block passed to #initialize" do
-      block_called = false
-      stub.instance_of(HighLevelSpec) do |o|
-        o.method_run_in_initialize
-      end
-      instance = HighLevelSpec.new(1, 2) {block_called = true}
-      instance.initialize_arguments.should == [1, 2]
-      block_called.should be_true
-    end
-  end
-
-  describe "RR recorded_calls" do
-    it "should verify method calls after the fact" do
-      stub(subject).pig_rabbit
-      subject.pig_rabbit("bacon", "bunny meat")
-      #subject.should have_received.pig_rabitt("bacon", "bunny meat")
-      received(subject).pig_rabbit("bacon", "bunny meat").call
-    end
-    
-    it "should verify method calls after the fact" do
-      stub(subject).pig_rabbit
-      lambda do
-        received(subject).pig_rabbit("bacon", "bunny meat").call
-      end.should raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
-    end
-  end
-  
-  class StrongTestObject
-    def method_with_no_arguments
-    end
-
-    def method_with_one_argument(string)
-    end
-
-    def method_with_two_arguments(string, integer)
-    end
-
-    def method_with_three_arguments_including_varargs(string, integer, *args)
-    end
-
-    def method_with_varargs(*args)
-    end
-  end
-
-  describe "strong" do
-    context "when the method does not exist" do
-      it "raises an exception" do
-        lambda do
-          strong.stub(StrongTestObject.new).something
-        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
-      end
-    end
-
-    context "when the method exists with no arguments" do
-      it "does not raise an exception" do
-        strong.stub(StrongTestObject.new).method_with_no_arguments
-      end
-    end
-
-    context "when the method has a different arity" do
-      it "raises an exception" do
-        lambda do
-          strong.stub(StrongTestObject.new).method_with_one_argument
-        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
-      end
-    end
-
-    context "when the method has accepts a variable number of arguments" do
-      it "does not raise an exception" do
-        strong.stub(StrongTestObject.new).method_with_varargs
-      end
-    end
-
-    context "when the method does not provide the required parameters before varargs" do
-      it "raises an exception" do
-        lambda do
-          strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs
-        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
-      end
-    end
-
-    context "when the minimum number of parameters are provided" do
-      it "does not raise an exception" do
-        strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs("one", 2)
-      end
-    end
-
-    context "when using instance_of and the method does not exist" do
-      it "raises an exception" do
-        lambda do
-          strong.stub.instance_of(StrongTestObject).something
-          StrongTestObject.new
-        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
-      end
-    end
-
-    context "when using instance_of and the method does exist" do
-      it "does not raise an exception" do
-        strong.stub.instance_of(StrongTestObject).method_with_no_arguments
-      end
-    end
-  end
-
-  describe "spy" do
-    it "should record all method invocations" do
-      subject = Object.new
-      def subject.something
-      end
-
-      def subject.something_else
-      end
-
-      spy(subject)
-
-      subject.something
-      subject.something_else
-      subject.to_s
-
-      received(subject).something.call
-      received(subject).something_else.call
-      received(subject).to_s.call
-    end
-  end
-end