rr 0.10.10 → 0.10.11

data/spec/rr/double_spec.rb

@@ -1,361 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
-
-module RR
-  describe Double do
-    it_should_behave_like "Swapped Space"
-    attr_reader :subject, :double_injection, :definition, :definition_creator, :double
-    before do
-      @subject = Object.new
-      def subject.foobar(a, b)
-        [b, a]
-      end
-      @double_injection = create_double_injection
-      @definition_creator = DoubleDefinitions::DoubleDefinitionCreator.new
-      @definition = DoubleDefinitions::DoubleDefinition.new(definition_creator, subject).
-        any_number_of_times.
-        with_any_args
-      @double = Double.new(double_injection, definition)
-    end
-
-    def create_double_injection
-      space.double_injection(subject, :foobar)
-    end
-
-    describe "#initialize" do
-      it "registers self with associated DoubleInjection" do
-        double_injection.doubles.should include(double)
-      end
-    end
-
-    describe "#ordered?" do
-      it "defaults to false" do
-        double.should_not be_ordered
-      end
-    end
-
-    describe "#call" do
-      describe "when verbose" do
-        attr_reader :original_stdout
-        before do
-          @original_stdout = $stdout
-        end
-
-        after do
-          $stdout = original_stdout
-        end
-
-        it "prints the message call" do
-          double.definition.verbose
-          $stdout = StringIO.new(output = "")
-          subject.foobar(1, 2)
-          output.strip.should == Double.formatted_name(:foobar, [1, 2])
-        end
-      end
-
-      describe "when not verbose" do
-        it "does not print the message call" do
-          output = nil
-          (class << double; self; end).__send__(:define_method, :puts) do |output|
-            output = output
-          end
-          subject.foobar(1, 2)
-          output.should be_nil
-        end
-      end
-
-      describe "when implemented by a lambda" do
-        it "calls the return lambda when implemented by a lambda" do
-          double.definition.returns {|arg| "returning #{arg}"}
-          subject.foobar(:foobar).should == "returning foobar"
-        end
-
-        it "calls and returns the after_call when after_call is set" do
-          double.definition.returns {|arg| "returning #{arg}"}.after_call do |value|
-            "#{value} after call"
-          end
-          subject.foobar(:foobar).should == "returning foobar after call"
-        end
-
-        it "returns nil when to returns is not set" do
-          subject.foobar.should be_nil
-        end
-
-        it "works when times_called is not set" do
-          double.definition.returns {:value}
-          subject.foobar
-        end
-
-        it "verifes the times_called does not exceed the TimesCalledExpectation" do
-          double.definition.times(2).returns {:value}
-
-          subject.foobar(:foobar)
-          subject.foobar(:foobar)
-          lambda {subject.foobar(:foobar)}.should raise_error(Errors::TimesCalledError)
-        end
-
-        it "raises DoubleOrderError when ordered and called out of order" do
-          double1 = double
-          double2 = Double.new(double_injection, DoubleDefinitions::DoubleDefinition.new(definition_creator, subject))
-
-          double1.definition.with(1).returns {:return_1}.once.ordered
-          double2.definition.with(2).returns {:return_2}.once.ordered
-
-          lambda do
-            subject.foobar(2)
-          end.should raise_error(
-          Errors::DoubleOrderError,
-          "foobar(2) called out of order in list\n" <<
-          "- foobar(1)\n" <<
-          "- foobar(2)"
-          )
-        end
-
-        it "dispatches to Space#verify_ordered_double when ordered" do
-          verify_ordered_double_called = false
-          passed_in_double = nil
-          space.method(:verify_ordered_double).arity.should == 1
-          (class << space; self; end).class_eval do
-            define_method :verify_ordered_double do |double|
-              passed_in_double = double
-              verify_ordered_double_called = true
-            end
-          end
-
-          double.definition.returns {:value}.ordered
-          subject.foobar(:foobar)
-          verify_ordered_double_called.should be_true
-          passed_in_double.should === double
-        end
-
-        it "does not dispatche to Space#verify_ordered_double when not ordered" do
-          verify_ordered_double_called = false
-          space.method(:verify_ordered_double).arity.should == 1
-          (class << space; self; end).class_eval do
-            define_method :verify_ordered_double do |double|
-              verify_ordered_double_called = true
-            end
-          end
-
-          double.definition.returns {:value}
-          subject.foobar(:foobar)
-          verify_ordered_double_called.should be_false
-        end
-
-        it "does not add block argument if no block passed in" do
-          double.definition.with(1, 2).returns {|*args| args}
-
-          args = subject.foobar(1, 2)
-          args.should == [1, 2]
-        end
-
-        it "makes the block the last argument" do
-          double.definition.with(1, 2).returns {|a, b, blk| blk}
-
-          block = subject.foobar(1, 2) {|a, b| [b, a]}
-          block.call(3, 4).should == [4, 3]
-        end
-
-        it "raises ArgumentError when yields was called and no block passed in" do
-          double.definition.with(1, 2).yields(55)
-
-          lambda do
-            subject.foobar(1, 2)
-          end.should raise_error(ArgumentError, "A Block must be passed into the method call when using yields")
-        end
-      end
-
-      describe "when implemented by a method" do
-        it "sends block to the method" do
-          class << subject
-            remove_method :foobar
-            def foobar(a, b)
-              yield(a, b)
-            end
-          end
-
-          double.definition.with(1, 2).implemented_by(subject.method(:foobar))
-
-          subject.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
-        end
-      end
-    end
-
-    describe "#exact_match?" do
-      context "when no expectation is set" do
-        it "raises a DoubleDefinitionError" do
-          double.definition.argument_expectation = nil
-          lambda do
-            double.exact_match?
-          end.should raise_error(Errors::DoubleDefinitionError)
-        end
-      end
-
-      context "when arguments are not an exact match" do
-        it "returns false" do
-          double.definition.with(1, 2, 3)
-          double.should_not be_exact_match(1, 2)
-          double.should_not be_exact_match(1)
-          double.should_not be_exact_match()
-          double.should_not be_exact_match("does not match")
-        end
-      end
-
-      context "when arguments are an exact match" do
-        it "returns true" do
-          double.definition.with(1, 2, 3)
-          double.should be_exact_match(1, 2, 3)
-        end
-      end
-    end
-
-    describe "#wildcard_match?" do
-      context "when no expectation set" do
-        it "raises a DoubleDefinitionError" do
-          double.definition.argument_expectation = nil
-          lambda do
-            double.wildcard_match?
-          end.should raise_error(Errors::DoubleDefinitionError)
-        end
-      end
-
-      context "when arguments are an exact match" do
-        it "returns true" do
-          double.definition.with(1, 2, 3)
-          double.should be_wildcard_match(1, 2, 3)
-          double.should_not be_wildcard_match(1, 2)
-          double.should_not be_wildcard_match(1)
-          double.should_not be_wildcard_match()
-          double.should_not be_wildcard_match("does not match")
-        end
-      end
-
-      context "when with_any_args" do
-        it "returns true" do
-          double.definition.with_any_args
-
-          double.should be_wildcard_match(1, 2, 3)
-          double.should be_wildcard_match(1, 2)
-          double.should be_wildcard_match(1)
-          double.should be_wildcard_match()
-          double.should be_wildcard_match("does not match")
-        end
-      end
-    end
-
-    describe "#attempt?" do
-      context "when TimesCalledExpectation#attempt? is true" do
-        it "returns true" do
-          double.definition.with(1, 2, 3).twice
-          subject.foobar(1, 2, 3)
-          double.times_called_expectation.should be_attempt
-          double.should be_attempt
-        end
-      end
-
-      context "when TimesCalledExpectation#attempt? is true" do
-        it "returns false" do
-          double.definition.with(1, 2, 3).twice
-          subject.foobar(1, 2, 3)
-          subject.foobar(1, 2, 3)
-          double.times_called_expectation.should_not be_attempt
-          double.should_not be_attempt
-        end
-      end
-
-      context "when there is no Times Called expectation" do
-        it "raises a DoubleDefinitionError" do
-          double.definition.with(1, 2, 3)
-          double.definition.times_matcher = nil
-          lambda do
-            double.should be_attempt
-          end.should raise_error(RR::Errors::DoubleDefinitionError)
-        end
-      end
-    end
-
-    describe "#verify" do
-      it "verifies that times called expectation was met" do
-        double.definition.twice.returns {:return_value}
-
-        lambda {double.verify}.should raise_error(Errors::TimesCalledError)
-        subject.foobar
-        lambda {double.verify}.should raise_error(Errors::TimesCalledError)
-        subject.foobar
-
-        lambda {double.verify}.should_not raise_error
-      end
-
-      it "does not raise an error when there is no times called expectation" do
-        lambda {double.verify}.should_not raise_error
-        subject.foobar
-        lambda {double.verify}.should_not raise_error
-        subject.foobar
-        lambda {double.verify}.should_not raise_error
-      end
-    end
-
-    describe "#terminal?" do
-      context "when times_called_expectation's terminal? is true" do
-        it "returns true" do
-          double.definition.once
-          double.times_called_expectation.should be_terminal
-          double.should be_terminal
-        end
-      end
-
-      context "when times_called_expectation's terminal? is false" do
-        it "returns false" do
-          double.definition.any_number_of_times
-          double.times_called_expectation.should_not be_terminal
-          double.should_not be_terminal
-        end
-      end
-
-      context "when there is no times_matcher" do
-        it "raises a DoubleDefinitionError" do
-          double.definition.times_matcher = nil
-          lambda do
-            double.should_not be_terminal
-          end.should raise_error(RR::Errors::DoubleDefinitionError)
-        end
-      end
-    end
-
-    describe "#method_name" do
-      it "returns the DoubleInjection's method_name" do
-        double_injection.method_name.should == :foobar
-        double.method_name.should == :foobar
-      end
-    end
-
-    describe "#expected_arguments" do
-      context "when there is an argument expectation" do
-        it "returns argument expectation's expected_arguments" do
-          double.definition.with(1, 2)
-          double.definition.argument_expectation.should_not be_nil
-          double.expected_arguments.should == [1, 2]
-        end
-      end
-
-      context "when there is no argument expectation" do
-        it "raises an DoubleDefinitionError" do
-          double.definition.argument_expectation = nil
-          lambda do
-            double.expected_arguments
-          end.should raise_error(Errors::DoubleDefinitionError)
-        end
-      end
-    end
-
-    describe "#formatted_name" do
-      it "renders the formatted name of the Double with no arguments" do
-        double.formatted_name.should == "foobar()"
-      end
-
-      it "renders the formatted name of the Double with arguments" do
-        double.definition.with(1, 2)
-        double.formatted_name.should == "foobar(1, 2)"
-      end
-    end
-  end
-end

data/spec/rr/expectations/times_called_expectation/times_called_expectation_spec.rb

@@ -1,38 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
-
-module RR
-  module Expectations
-    describe TimesCalledExpectation do
-      context "with a failure" do
-        it_should_behave_like "RR::Expectations::TimesCalledExpectation"
-        attr_reader :times, :matcher, :expectation
-
-        before do
-          @times = 0
-          double.definition.times(0)
-          @matcher = double.definition.times_matcher
-          @expectation = TimesCalledExpectation.new(double)
-        end
-
-        describe "#attempt!" do
-          it "raises error that includes the double" do
-            lambda {expectation.attempt}.should raise_error(
-              RR::Errors::TimesCalledError,
-              "#{double.formatted_name}\n#{matcher.error_message(1)}"
-            )
-          end
-        end
-
-        describe "#verify!" do
-          it "raises error with passed in message prepended" do
-            expectation.instance_variable_set(:@times_called, 1)
-            lambda {expectation.verify!}.should raise_error(
-              RR::Errors::TimesCalledError,
-              "#{double.formatted_name}\n#{matcher.error_message(1)}"
-            )
-          end
-        end
-      end
-    end
-  end
-end