rr 0.3.11 → 0.4.0

data/lib/rr/times_called_matchers/terminal.rb

@@ -1,20 +1,20 @@
 module RR
-module TimesCalledMatchers
-  # Including this module marks the TimesCalledMatcher as Terminal.
-  # Being Terminal the Scenario will "terminate" when times called is
-  # finite.
-  #
-  # The Scenario that uses a Terminal TimesCalledMatcher will
-  # eventually be passed over to the next Scenario when passed
-  # the matching arguments enough times. This is done by the attempt?
-  # method returning false when executed a finite number of times.
-  #
-  # This is in opposition to NonTerminal TimesCalledMatchers, where
-  # attempt? will always return true.
-  module Terminal
-    def terminal?
-      true
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as Terminal.
+    # Being Terminal the Double will "terminate" when times called is
+    # finite.
+    #
+    # The Double that uses a Terminal TimesCalledMatcher will
+    # eventually be passed over to the next Double when passed
+    # the matching arguments enough times. This is done by the attempt?
+    # method returning false when executed a finite number of times.
+    #
+    # This is in opposition to NonTerminal TimesCalledMatchers, where
+    # attempt? will always return true.
+    module Terminal #:nodoc:
+      def terminal?
+        true
+      end
     end
   end
-end
 end

data/lib/rr/times_called_matchers/times_called_matcher.rb

@@ -1,44 +1,44 @@
 module RR
-module TimesCalledMatchers
-  class TimesCalledMatcher
-    class << self
-      def create(value)
-        return value if value.is_a?(TimesCalledMatcher)
-        return IntegerMatcher.new(value) if value.is_a?(Integer)
-        return RangeMatcher.new(value) if value.is_a?(Range )
-        return ProcMatcher.new(value) if value.is_a?(Proc)
-        raise ArgumentError, "There is no TimesCalledMatcher for #{value.inspect}."
+  module TimesCalledMatchers
+    class TimesCalledMatcher #:nodoc:
+      class << self
+        def create(value)
+          return value if value.is_a?(TimesCalledMatcher)
+          return IntegerMatcher.new(value) if value.is_a?(Integer)
+          return RangeMatcher.new(value) if value.is_a?(Range )
+          return ProcMatcher.new(value) if value.is_a?(Proc)
+          raise ArgumentError, "There is no TimesCalledMatcher for #{value.inspect}."
+        end
       end
-    end
 
-    attr_reader :times
-    
-    def initialize(times)
-      @times = times
-    end
+      attr_reader :times
 
-    def matches?(times_called)
-    end
+      def initialize(times)
+        @times = times
+      end
 
-    def attempt?(times_called)
-    end
+      def matches?(times_called)
+      end
 
-    def error_message(times_called)
-      "Called #{times_called.inspect} #{pluralized_time(times_called)}.\n#{expected_message_part}"
-    end
+      def attempt?(times_called)
+      end
 
-    def ==(other)
-      self.class == other.class && self.times == other.times
-    end
+      def error_message(times_called)
+        "Called #{times_called.inspect} #{pluralized_time(times_called)}.\n#{expected_message_part}"
+      end
 
-    protected
-    def expected_message_part
-      "Expected #{@times.inspect} times."
-    end
+      def ==(other)
+        self.class == other.class && self.times == other.times
+      end
 
-    def pluralized_time(times_called)
-      (times_called == 1) ? "time" : "times"
+      protected
+      def expected_message_part
+        "Expected #{@times.inspect} times."
+      end
+
+      def pluralized_time(times_called)
+        (times_called == 1) ? "time" : "times"
+      end
     end
   end
-end
 end

data/spec/core_spec_suite.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "spec"
+
+class CoreExampleSuite
+  def run
+    files = Dir["#{File.dirname(__FILE__)}/**/*_spec.rb"]
+    files.delete_if {|file| file.include?('rspec/')}
+    files.delete_if {|file| file.include?('test_unit/')}
+    puts "Running Rspec Example Suite"
+    files.each do |file|
+      require file
+    end
+  end
+end
+
+if $0 == __FILE__
+  CoreExampleSuite.new.run
+end

data/{examples → spec}/environment_fixture_setup.rb

@@ -3,5 +3,4 @@ require "spec"
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift "#{dir}/../lib"
 require "rr"
-require "ruby-debug"
 require "pp"

data/{examples/high_level_example.rb → spec/high_level_spec.rb}

@@ -1,10 +1,10 @@
 dir = File.dirname(__FILE__)
-require "#{dir}/example_helper"
+require "#{dir}/spec_helper"
 
 describe "RR", :shared => true do
   before(:each) do
     @obj = Object.new
-    extend RR::Extensions::InstanceMethods
+    extend RR::Adapters::RRMethods
   end
 
   after(:each) do
@@ -58,26 +58,26 @@ describe "RR mock:" do
     ).should == "value 1"
     proc do
       @obj.foobar(:failure)
-    end.should raise_error( RR::Errors::ScenarioNotFoundError )
+    end.should raise_error( RR::Errors::DoubleNotFoundError )
   end
 end
 
-describe "RR probe or proxy:" do
+describe "RR proxy:" do
   it_should_behave_like "RR"
 
-  it "probes via inline call" do
+  it "proxies via inline call" do
     expected_to_s_value = @obj.to_s
-    mock.probe(@obj).to_s
+    mock.proxy(@obj).to_s
     @obj.to_s.should == expected_to_s_value
     proc {@obj.to_s}.should raise_error
   end
 
-  it "probe allows ordering" do
+  it "proxy allows ordering" do
     def @obj.to_s(arg)
       "Original to_s with arg #{arg}"
     end
-    mock.probe(@obj).to_s(:foo).ordered
-    mock.probe(@obj).to_s(:bar).twice.ordered
+    mock.proxy(@obj).to_s(:foo).ordered
+    mock.proxy(@obj).to_s(:bar).twice.ordered
 
     @obj.to_s(:foo).should == "Original to_s with arg foo"
     @obj.to_s(:bar).should == "Original to_s with arg bar"
@@ -98,7 +98,7 @@ describe "RR probe or proxy:" do
     proc {@obj.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
   end
 
-  it "probes via block" do
+  it "proxies via block" do
     def @obj.foobar_1(*args)
       :original_value_1
     end
@@ -107,7 +107,7 @@ describe "RR probe or proxy:" do
       :original_value_2
     end
 
-    mock.probe @obj do |c|
+    mock.proxy @obj do |c|
       c.foobar_1(1)
       c.foobar_2
     end

data/spec/rr/adapters/rr_methods_argument_matcher_spec.rb

@@ -0,0 +1,67 @@
+require "spec/spec_helper"
+
+module RR
+  module Adapters
+    describe RRMethods do
+      describe "#anything" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Anything matcher" do
+          anything.should == WildcardMatchers::Anything.new
+        end
+
+        it "rr_anything returns an Anything matcher" do
+          rr_anything.should == WildcardMatchers::Anything.new
+        end
+      end
+
+      describe "#is_a" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an IsA matcher" do
+          is_a(Integer).should == WildcardMatchers::IsA.new(Integer)
+        end
+
+        it "rr_is_a returns an IsA matcher" do
+          rr_is_a(Integer).should == WildcardMatchers::IsA.new(Integer)
+        end
+      end
+
+      describe "#numeric" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Numeric matcher" do
+          numeric.should == WildcardMatchers::Numeric.new
+        end
+
+        it "rr_numeric returns an Numeric matcher" do
+          rr_numeric.should == WildcardMatchers::Numeric.new
+        end
+      end
+
+      describe "#boolean" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns an Boolean matcher" do
+          boolean.should == WildcardMatchers::Boolean.new
+        end
+
+        it "rr_boolean returns an Boolean matcher" do
+          rr_boolean.should == WildcardMatchers::Boolean.new
+        end
+      end
+
+      describe "#duck_type" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        it "returns a DuckType matcher" do
+          duck_type(:one, :two).should == WildcardMatchers::DuckType.new(:one, :two)
+        end
+
+        it "rr_duck_type returns a DuckType matcher" do
+          rr_duck_type(:one, :two).should == WildcardMatchers::DuckType.new(:one, :two)
+        end
+      end
+    end
+  end
+end

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -0,0 +1,365 @@
+require "spec/spec_helper"
+
+module RR
+  module Adapters
+    describe RRMethods do
+      describe "#mock" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        before do
+          @subject = Object.new
+          class << @subject
+            def foobar(*args)
+              :original_value
+            end
+          end
+        end
+
+        it "returns a DoubleCreator when passed no arguments" do
+          mock.should be_instance_of(DoubleCreator)
+        end
+
+        it "sets up the RR mock call chain" do
+          creates_mock_call_chain(mock(@subject))
+        end
+
+        it "#rr_mock sets up the RR mock call chain" do
+          creates_mock_call_chain(rr_mock(@subject))
+        end
+
+        it "creates a mock Double for method when passed a second argument" do
+          creates_scenario_with_method_name(mock(@subject, :foobar))
+        end
+
+        it "creates a mock Double for method when passed a second argument with rr_mock" do
+          creates_scenario_with_method_name(rr_mock(@subject, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            mock(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.with(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @subject.foobar(1, 2).should == :baz
+        end
+
+        def creates_mock_call_chain(creator)
+          scenario = creator.foobar(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @subject.foobar(1, 2).should == :baz
+        end
+      end
+
+      describe "#stub" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        before do
+          @subject = Object.new
+          class << @subject
+            def foobar(*args)
+              :original_value
+            end
+          end
+        end
+
+        it "returns a DoubleCreator when passed no arguments" do
+          stub.should be_instance_of(DoubleCreator)
+        end
+
+        it "sets up the RR stub call chain" do
+          creates_stub_call_chain(stub(@subject))
+        end
+
+        it "#rr_stub sets up the RR stub call chain" do
+          creates_stub_call_chain(rr_stub(@subject))
+        end
+
+        it "creates a stub Double for method when passed a second argument" do
+          creates_scenario_with_method_name(stub(@subject, :foobar))
+        end
+
+        it "#rr_stub creates a stub Double for method when passed a second argument" do
+          creates_scenario_with_method_name(rr_stub(@subject, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            stub(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.with(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          @subject.foobar(1, 2).should == :baz
+        end
+
+        def creates_stub_call_chain(creator)
+          scenario = creator.foobar(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          @subject.foobar(1, 2).should == :baz
+        end
+      end
+
+      describe "#proxy and #mock" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        before do
+          @subject = Object.new
+          class << @subject
+            def foobar(*args)
+              :original_value
+            end
+          end
+        end
+
+        it "#proxy returns a DoubleCreator when passed no arguments" do
+          proxy.should be_instance_of(DoubleCreator)
+        end
+
+        it "#proxy sets up the RR proxy call chain" do
+          creates_mock_proxy_call_chain(mock.proxy(@subject))
+        end
+
+        it "#rr_proxy sets up the RR proxy call chain" do
+          creates_mock_proxy_call_chain(rr_mock.proxy(@subject))
+        end
+
+        it "#mock_proxy sets up the RR proxy call chain" do
+          creates_mock_proxy_call_chain(mock.proxy(@subject))
+        end
+
+        it "#rr_mock_proxy sets up the RR proxy call chain with rr_proxy" do
+          creates_mock_proxy_call_chain(rr_mock.proxy(@subject))
+        end
+
+        it "#proxy creates a mock Double for method when passed a second argument" do
+          creates_scenario_with_method_name(mock.proxy(@subject, :foobar))
+        end
+
+        it "#rr_proxy creates a mock Double for method when passed a second argument with rr_mock" do
+          creates_scenario_with_method_name(rr_proxy.mock(@subject, :foobar))
+        end
+
+        it "#mock_proxy creates a mock Double for method when passed a second argument" do
+          creates_scenario_with_method_name(mock.proxy(@subject, :foobar))
+        end
+
+        it "#rr_mock_proxy creates a mock Double for method when passed a second argument with rr_mock" do
+          creates_scenario_with_method_name(rr_mock.proxy(@subject, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            mock.proxy(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.with(1, 2)
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @subject.foobar(1, 2).should == :original_value
+        end
+
+        def creates_mock_proxy_call_chain(creator)
+          scenario = creator.foobar(1, 2)
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @subject.foobar(1, 2).should == :original_value
+        end
+      end
+
+      describe "#stub and #proxy" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        before do
+          @subject = Object.new
+          class << @subject
+            def foobar(*args)
+              :original_value
+            end
+          end
+        end
+
+        it "returns a DoubleCreator when passed no arguments" do
+          stub.proxy.should be_instance_of(DoubleCreator)
+        end
+
+        it "sets up the RR proxy call chain" do
+          creates_stub_proxy_call_chain(stub.proxy(@subject))
+        end
+
+        it "sets up the RR proxy call chain" do
+          creates_stub_proxy_call_chain(rr_stub.proxy(@subject))
+        end
+
+        it "#stub.proxy creates a stub Double for method when passed a second argument" do
+          creates_scenario_with_method_name(stub.proxy(@subject, :foobar))
+        end
+
+        it "#rr_stub.proxy creates a stub Double for method when passed a second argument with rr_stub" do
+          creates_scenario_with_method_name(rr_stub.proxy(@subject, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            stub.proxy(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+          @subject.foobar(:something).should == :original_value
+        end
+
+        def creates_stub_proxy_call_chain(creator)
+          scenario = creator.foobar
+          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+          @subject.foobar(1, 2).should == :original_value
+        end
+      end
+
+      describe "#do_not_allow" do
+        it_should_behave_like "RR::Adapters::RRMethods"
+
+        before do
+          @subject = Object.new
+          class << @subject
+            def foobar(*args)
+              :original_value
+            end
+          end
+        end
+
+        it "returns a DoubleCreator when passed no arguments" do
+          do_not_allow.should be_instance_of(DoubleCreator)
+        end
+
+        it "sets up the RR do_not_allow call chain" do
+          creates_do_not_allow_call_chain(dont_allow(@subject))
+          creates_do_not_allow_call_chain(rr_dont_allow(@subject))
+          creates_do_not_allow_call_chain(dont_call(@subject))
+          creates_do_not_allow_call_chain(rr_dont_call(@subject))
+          creates_do_not_allow_call_chain(do_not_allow(@subject))
+          creates_do_not_allow_call_chain(rr_do_not_allow(@subject))
+          creates_do_not_allow_call_chain(dont_allow(@subject))
+          creates_do_not_allow_call_chain(rr_dont_allow(@subject))
+        end
+
+        it "creates a mock Double for method when passed a second argument" do
+          creates_scenario_with_method_name(dont_allow(@subject, :foobar))
+          creates_scenario_with_method_name(rr_dont_allow(@subject, :foobar))
+          creates_scenario_with_method_name(dont_call(@subject, :foobar))
+          creates_scenario_with_method_name(rr_dont_call(@subject, :foobar))
+          creates_scenario_with_method_name(do_not_allow(@subject, :foobar))
+          creates_scenario_with_method_name(rr_do_not_allow(@subject, :foobar))
+          creates_scenario_with_method_name(dont_allow(@subject, :foobar))
+          creates_scenario_with_method_name(rr_dont_allow(@subject, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            do_not_allow(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.with(1, 2)
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          proc do
+            @subject.foobar(1, 2)
+          end.should raise_error(Errors::TimesCalledError)
+          reset
+          nil
+        end
+
+        def creates_do_not_allow_call_chain(creator)
+          scenario = creator.foobar(1, 2)
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          proc do
+            @subject.foobar(1, 2)
+          end.should raise_error(Errors::TimesCalledError)
+          reset
+          nil
+        end
+      end
+
+      describe DoubleCreator, "#instance_of and #mock" do
+        before do
+          @klass = Class.new
+        end
+
+        it "returns a DoubleCreator when passed no arguments" do
+          instance_of.instance_of.should be_instance_of(DoubleCreator)
+        end
+
+        it "sets up the RR instance_of call chain" do
+          creates_instance_of_call_chain(instance_of.mock(@klass))
+        end
+
+        it "#rr_instance_of sets up the RR instance_of call chain" do
+          creates_instance_of_call_chain(rr_instance_of.mock(@klass))
+        end
+
+        it "creates a instance_of Double for method when passed a second argument" do
+          creates_scenario_with_method_name(instance_of.mock(@klass, :foobar))
+        end
+
+        it "creates a instance_of Double for method when passed a second argument with rr_instance_of" do
+          creates_scenario_with_method_name(rr_instance_of.mock(@klass, :foobar))
+        end
+
+        it "raises error if passed a method name and a block" do
+          proc do
+            instance_of.mock(@klass, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+
+        def creates_scenario_with_method_name(scenario)
+          scenario.with(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @klass.new.foobar(1, 2).should == :baz
+        end
+
+        def creates_instance_of_call_chain(creator)
+          scenario = creator.foobar(1, 2) {:baz}
+          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+          @klass.new.foobar(1, 2).should == :baz
+        end
+      end
+    end
+  end
+end