rr 1.1.1 → 1.1.2.rc1

data/spec/suites/rspec_2/unit/spy_verification_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+class Alpha
+  def bob
+  end
+end
+
+describe RR::SpyVerification do
+  subject { Object.new }
+
+  attr_reader :recorded_calls
+
+  include_examples "Swapped Space"
+
+  include RR::Adapters::RRMethods
+
+  before(:each) do
+    stub(subject).foobar
+    @recorded_calls = RR::RecordedCalls.new([[subject, :foobar, [1, 2], nil]])
+  end
+
+  describe "#call" do
+    context "when a subject is expected to receive a method with exact arguments" do
+      context "when the number of times the subject received a method is not specified" do
+        context "when there is an exact match one time" do
+          it "verifies that the method with arguments was called once" do
+            subject.foobar(1, 2)
+            received(subject).foobar(1, 2).call
+            subject.foobar(1, 2)
+            expect {
+              received(subject).foobar(1, 2).call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+          end
+        end
+      end
+
+      context "when the number of times the subject received a method is specified" do
+        context "as one time" do
+          it "verifies that the method with arugments was called once" do
+            subject.foobar(1, 2)
+            received(subject).foobar(1, 2).once.call
+            subject.foobar(1, 2)
+            expect {
+              received(subject).foobar(1, 2).once.call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+          end
+        end
+
+        context "as an at least matcher" do
+          it "verifies that the method with arugments was called at least the specified number of times" do
+            subject.foobar(1, 2)
+            expect {
+              received(subject).foobar(1, 2).at_least(2).call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+            subject.foobar(1, 2)
+            received(subject).foobar(1, 2).at_least(2).call
+            subject.foobar(1, 2)
+            received(subject).foobar(1, 2).at_least(2).call
+          end
+        end
+      end
+    end
+
+    context "when a subject is expected to receive a method with wildcard arguments" do
+      context "when the number of times the subject received a method is not specified" do
+        context "when there is a wildcard match one time" do
+          it "verifies that the method with arguments was called once" do
+            subject.foobar(1, 2)
+            received(subject).foobar(1, is_a(Fixnum)).call
+            subject.foobar(1, 2)
+            expect {
+              received(subject).foobar(1, is_a(Fixnum)).call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+          end
+        end
+      end
+
+      context "when the number of times the subject received a method is specified" do
+        context "as one time" do
+          it "verifies that the method with arugments was called once" do
+            subject.foobar(1, 2)
+            received(subject).foobar(1, is_a(Fixnum)).once.call
+            subject.foobar(1, 2)
+            expect {
+              received(subject).foobar(1, is_a(Fixnum)).once.call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+          end
+        end
+
+        context "as an at least matcher" do
+          it "verifies that the method with arugments was called at least the specified number of times" do
+            subject.foobar(1, is_a(Fixnum))
+            expect {
+              received(subject).foobar(1, is_a(Fixnum)).at_least(2).call
+            }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+            subject.foobar(1, 2)
+            received(subject).foobar(1, is_a(Fixnum)).at_least(2).call
+            subject.foobar(1, 2)
+            received(subject).foobar(1, is_a(Fixnum)).at_least(2).call
+          end
+        end
+      end
+    end
+
+    context "when checking for ordering" do
+      it "when the order is incorrect; raises an error" do
+        subject.foobar(3, 4)
+        subject.foobar(1, 2)
+        expect {
+          received(subject).foobar(1, 2).ordered.call
+          received(subject).foobar(3, 4).ordered.call
+        }.to raise_error(RR::Errors::SpyVerificationErrors::InvocationCountError)
+      end
+
+      it "when the order is correct; does not raise an error" do
+        subject.foobar(1, 2)
+        subject.foobar(1, 2)
+        subject.foobar(3, 4)
+        received(subject).foobar(1, 2).ordered.call
+        received(subject).foobar(3, 4).ordered.call
+      end
+    end
+
+    context "when the subject is expected where there is not DoubleInjection" do
+      it "raises a DoubleInjectionNotFoundError" do
+        expect(::RR::Injections::DoubleInjection.exists?(subject, :method_that_does_not_exist)).to be_false
+        expect {
+          received(subject).method_that_does_not_exist.call
+        }.to raise_error(RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError)
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/any_times_matcher_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe AnyTimesMatcher do
+      attr_reader :matcher
+      before do
+        @matcher = AnyTimesMatcher.new
+      end
+
+      describe AnyTimesMatcher, "#possible_match?" do
+        it "always returns true" do
+          expect(matcher).to be_possible_match(0)
+          expect(matcher).to be_possible_match(99999)
+        end
+      end
+
+      describe AnyTimesMatcher, "#matches?" do
+        it "always returns true" do
+          expect(matcher).to be_matches(0)
+          expect(matcher).to be_matches(99999)
+        end
+      end
+
+      describe AnyTimesMatcher, "#attempt?" do
+        it "always returns true" do
+          expect(matcher).to be_attempt(0)
+          expect(matcher).to be_attempt(99999)
+        end
+      end
+
+      describe AnyTimesMatcher, "#terminal?" do
+        it "returns false" do
+          matcher.should_not be_terminal
+        end
+      end
+
+      describe AnyTimesMatcher, "#error_message" do
+        it "has an error message" do
+          expect(matcher.error_message(2)).to eq \
+            "Called 2 times.\nExpected any number of times."
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/at_least_matcher_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe AtLeastMatcher do
+      attr_reader :matcher, :times
+      before do
+        @times = 3
+        @matcher = AtLeastMatcher.new(times)
+      end
+
+      describe "#possible_match?" do
+        it "always returns true" do
+          expect(matcher).to be_possible_match(99999)
+        end
+      end
+
+      describe "#matches?" do
+        it "returns false when times_called less than times" do
+          matcher.should_not be_matches(2)
+        end
+
+        it "returns true when times_called == times" do
+          expect(matcher).to be_matches(3)
+        end
+
+        it "returns true when times_called > times" do
+          expect(matcher).to be_matches(4)
+        end
+      end
+
+      describe "#attempt?" do
+        it "always returns true" do
+          expect(matcher).to be_attempt(1)
+          expect(matcher).to be_attempt(100000)
+        end
+      end
+
+      describe AnyTimesMatcher, "#terminal?" do
+        it "returns false" do
+          matcher.should_not be_terminal
+        end
+      end
+
+      describe "#error_message" do
+        it "has an error message" do
+          expect(matcher.error_message(2)).to eq \
+            "Called 2 times.\nExpected at least 3 times."
+        end
+      end
+    end
+
+  end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/at_most_matcher_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+module TimesCalledMatchers
+  describe AtMostMatcher do
+    attr_reader :matcher, :times
+    before do
+      @times = 3
+      @matcher = AtMostMatcher.new(times)
+    end
+
+    describe AtMostMatcher, "#possible_match?" do
+      it "returns true when times called < times" do
+        expect(matcher).to be_possible_match(2)
+      end
+
+      it "returns true when times called == times" do
+        expect(matcher).to be_possible_match(3)
+      end
+
+      it "returns false when times called > times" do
+        matcher.should_not be_possible_match(4)
+      end
+    end
+
+    describe AtMostMatcher, "#matches?" do
+      it "returns true when times_called less than times" do
+        expect(matcher).to be_matches(2)
+      end
+
+      it "returns true when times_called == times" do
+        expect(matcher).to be_matches(3)
+      end
+
+      it "returns false when times_called > times" do
+        matcher.should_not be_matches(4)
+      end
+    end
+
+    describe AtMostMatcher, "#attempt?" do
+      it "returns true when less than expected times" do
+        expect(matcher).to be_attempt(2)
+      end
+
+      it "returns false when == expected times" do
+        matcher.should_not be_attempt(3)
+      end
+
+      it "returns false when > expected times" do
+        matcher.should_not be_attempt(4)
+      end
+    end
+
+    describe AnyTimesMatcher, "#terminal?" do
+      it "returns true" do
+        expect(matcher).to be_terminal
+      end
+    end
+
+    describe AtMostMatcher, "#error_message" do
+      it "has an error message" do
+        expect(matcher.error_message(5)).to eq \
+          "Called 5 times.\nExpected at most 3 times."
+      end
+    end
+  end
+
+end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/integer_matcher_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe IntegerMatcher do
+      attr_reader :matcher, :times
+      before do
+        @times = 3
+        @matcher = IntegerMatcher.new(times)
+      end
+
+      describe "#possible_match?" do
+        it "returns true when times called < times" do
+          expect(matcher).to be_possible_match(2)
+        end
+
+        it "returns true when times called == times" do
+          expect(matcher).to be_possible_match(3)
+        end
+
+        it "returns false when times called > times" do
+          matcher.should_not be_possible_match(4)
+        end
+      end
+
+      describe "#matches?" do
+        it "returns false when times_called less than times" do
+          matcher.should_not be_matches(2)
+        end
+
+        it "returns true when times_called == times" do
+          expect(matcher).to be_matches(3)
+        end
+
+        it "returns false when times_called > times" do
+          matcher.should_not be_matches(4)
+        end
+      end
+
+      describe "#attempt?" do
+        it "returns true when less than expected times" do
+          expect(matcher).to be_attempt(2)
+        end
+
+        it "returns false when == expected times" do
+          matcher.should_not be_attempt(3)
+        end
+
+        it "returns false when > expected times" do
+          matcher.should_not be_attempt(4)
+        end
+      end
+
+      describe AnyTimesMatcher, "#terminal?" do
+        it "returns true" do
+          expect(matcher).to be_terminal
+        end
+      end
+
+      describe "#error_message" do
+        it "has an error message" do
+          expect(matcher.error_message(2)).to eq \
+            "Called 2 times.\nExpected 3 times."
+        end
+      end
+    end
+
+  end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/proc_matcher_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe ProcMatcher do
+      attr_reader :matcher, :times
+      before do
+        @times = lambda {|other| other == 3}
+        @matcher = ProcMatcher.new(times)
+      end
+
+      describe "#possible_match?" do
+        it "always returns true" do
+          expect(matcher).to be_possible_match(2)
+          expect(matcher).to be_possible_match(3)
+          expect(matcher).to be_possible_match(10)
+        end
+      end
+
+      describe "#matches?" do
+        it "returns false when lambda returns false" do
+          expect(times.call(2)).to be_false
+          matcher.should_not be_matches(2)
+        end
+
+        it "returns true when lambda returns true" do
+          expect(times.call(3)).to be_true
+          expect(matcher).to be_matches(3)
+        end
+      end
+
+      describe "#attempt?" do
+        it "always returns true" do
+          expect(matcher).to be_attempt(2)
+          expect(matcher).to be_attempt(3)
+          expect(matcher).to be_attempt(10)
+        end
+      end
+
+      describe "#terminal?" do
+        it "returns false" do
+          matcher.should_not be_terminal
+        end
+      end
+
+      describe "#error_message" do
+        it "has an error message" do
+          expect(matcher.error_message(1)).to match(/Called 1 time.\nExpected #<Proc.*> times./)
+        end
+      end
+    end
+
+  end
+end

data/spec/suites/rspec_2/unit/times_called_matchers/range_matcher_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe RangeMatcher do
+      attr_reader :matcher, :times
+      before do
+        @times = 2..4
+        @matcher = RangeMatcher.new(times)
+      end
+
+      describe "#possible_match?" do
+        it "returns true when times called < start of range" do
+          expect(matcher).to be_possible_match(1)
+        end
+
+        it "returns true when times called in range" do
+          expect(matcher).to be_possible_match(2)
+          expect(matcher).to be_possible_match(3)
+          expect(matcher).to be_possible_match(4)
+        end
+
+        it "returns false when times called > end of range" do
+          matcher.should_not be_possible_match(5)
+        end
+      end
+
+      describe "#matches?" do
+        it "returns false when times_called less than start of range" do
+          matcher.should_not be_matches(1)
+        end
+
+        it "returns true when times_called in range" do
+          expect(matcher).to be_matches(2)
+          expect(matcher).to be_matches(3)
+          expect(matcher).to be_matches(4)
+        end
+
+        it "returns false when times_called > end of range" do
+          matcher.should_not be_matches(5)
+        end
+      end
+
+      describe "#attempt?" do
+        it "returns true when less than start of range" do
+          expect(matcher).to be_attempt(1)
+        end
+
+        it "returns true when in range" do
+          expect(matcher).to be_attempt(2)
+          expect(matcher).to be_attempt(3)
+          expect(matcher).to be_attempt(4)
+        end
+
+        it "returns false when > end of range" do
+          matcher.should_not be_attempt(5)
+        end
+      end
+
+      describe "#terminal?" do
+        it "returns true" do
+          expect(matcher).to be_terminal
+        end
+      end
+
+      describe "#error_message" do
+        it "has an error message" do
+          expect(matcher.error_message(1)).to eq \
+            "Called 1 time.\nExpected 2..4 times."
+        end
+      end
+    end
+
+  end
+end