rr 1.1.1 → 1.1.2.rc1

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

@@ -0,0 +1,117 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module TimesCalledMatchers
+    describe TimesCalledMatcher do
+      describe ".create" do
+        describe "when passed a AnyTimesMatcher" do
+          it "returns the passed in argument" do
+            matcher = AnyTimesMatcher.new
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a AtLeastMatcher" do
+          it "returns the passed in argument" do
+            matcher = AtLeastMatcher.new(5)
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a AtMostMatcher" do
+          it "returns the passed in argument" do
+            matcher = AtMostMatcher.new(5)
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a IntegerMatcher" do
+          it "returns the passed in argument" do
+            matcher = IntegerMatcher.new(5)
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a Integer" do
+          it "returns IntegerMatcher" do
+            expect(TimesCalledMatcher.create(5)).to eq IntegerMatcher.new(5)
+          end
+        end
+
+        describe "when passed a ProcMatcher" do
+          it "returns the passed in argument" do
+            matcher = ProcMatcher.new(lambda {|other| other == 5})
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a Lambda" do
+          it "returns ProcMatcher" do
+            value = lambda {|other| other == 5}
+            expect(TimesCalledMatcher.create(value)).to eq ProcMatcher.new(value)
+          end
+        end
+
+        describe "when passed a IntegerMatcher" do
+          it "returns the passed in argument" do
+            matcher = RangeMatcher.new(2..4)
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed a Integer" do
+          it "returns RangeMatcher" do
+            expect(TimesCalledMatcher.create(2..4)).to eq RangeMatcher.new(2..4)
+          end
+        end
+
+        describe "when passed a TimesCalledMatcher" do
+          it "returns the passed in argument" do
+            matcher = TimesCalledMatcher.new(5)
+            expect(TimesCalledMatcher.create(matcher)).to equal matcher
+          end
+        end
+
+        describe "when passed an unsupported type" do
+          it "raises an ArgumentError" do
+            matcher = Object.new
+            expect {
+              TimesCalledMatcher.create(matcher)
+            }.to raise_error(ArgumentError, "There is no TimesCalledMatcher for #{matcher.inspect}.")
+          end
+        end
+      end
+
+      describe "#error_message" do
+        before do
+          @times = 3
+          @matcher = TimesCalledMatcher.new(@times)
+        end
+
+        it "has an error message" do
+          expect(@matcher.error_message(5)).to eq \
+            "Called 5 times.\nExpected 3 times."
+        end
+      end
+
+      describe "#==" do
+        before do
+          @times = 3
+          @matcher = TimesCalledMatcher.new(@times)
+        end
+
+        it "returns true when other is the same class and times are ==" do
+          expect(@matcher).to eq TimesCalledMatcher.new(@times)
+        end
+
+        it "returns false when other is a different class and times are ==" do
+          expect(@matcher).to_not eq IntegerMatcher.new(@times)
+        end
+
+        it "returns false when is the same class and times are not ==" do
+          expect(@matcher).to_not eq TimesCalledMatcher.new(1)
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/anything_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+module RR
+  module WildcardMatchers
+    describe Anything do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        it "always returns true when given any object" do
+          should wildcard_match(Object.new)
+          should wildcard_match(:symbol)
+          should wildcard_match([1, 2, 3])
+        end
+      end
+
+      describe '#==' do
+        it "returns true when given an Anything object" do
+          should equal_match(described_class.new)
+        end
+
+        it "returns false when not given an Anything object whatsoever" do
+          should_not equal_match(:whatever)
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          expect(subject.inspect).to eq "anything"
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/boolean_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+module RR
+  module WildcardMatchers
+    describe Boolean do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        it "returns true when given a Boolean" do
+          should wildcard_match(described_class.new)
+        end
+
+        it "returns true when given a boolean" do
+          should wildcard_match(true)
+          should wildcard_match(false)
+        end
+
+        it "returns false when not given a boolean" do
+          should_not wildcard_match(:something_else)
+        end
+      end
+
+      describe "#==" do
+        it "returns true when given a Boolean" do
+          should equal_match(described_class.new)
+        end
+
+        it "returns false even when given a boolean that wildcard matches this Boolean" do
+          should_not equal_match(true)
+          should_not equal_match(false)
+        end
+
+        it "returns false when not given a Boolean whatsoever" do
+          should_not equal_match(:something_else)
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          expect(subject.inspect).to eq "boolean"
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/duck_type_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'ostruct'
+
+module RR
+  module WildcardMatchers
+    describe DuckType do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        subject { described_class.new(:quack, :waddle) }
+
+        it "returns true when given DuckType is a copy of this DuckType" do
+          matcher2 = described_class.new(:quack, :waddle)
+          should wildcard_match(matcher2)
+        end
+
+        it "returns true when given object responds to all methods" do
+          object = OpenStruct.new(:quack => 'x', :waddle => 'x')
+          should wildcard_match(object)
+        end
+
+        it "returns false when given object responds to only some methods" do
+          object = OpenStruct.new(:quack => 'x')
+          should_not wildcard_match(object)
+        end
+
+        it "returns false when given object responds to no methods" do
+          object = Object.new
+          should_not wildcard_match(object)
+        end
+      end
+
+      describe '#==' do
+        subject { described_class.new(:quack, :waddle) }
+
+        it "returns true when given DuckType is a copy of this DuckType" do
+          matcher2 = described_class.new(:quack, :waddle)
+          should equal_match(matcher2)
+        end
+
+        it "returns false when given DuckType is not a copy of this DuckType" do
+          matcher2 = described_class.new(:something_else)
+          should_not equal_match(matcher2)
+        end
+
+        it "returns false even when given a DuckType that wildcard matches this DuckType" do
+          object = OpenStruct.new(:quack => 'x', :waddle => 'x')
+          should_not equal_match(object)
+        end
+
+        it "returns false when not given a DuckType object whatsoever" do
+          should_not equal_match(:something_else)
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          matcher = described_class.new(:quack, :waddle)
+          expect(matcher.inspect).to eq "duck_type(:quack, :waddle)"
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/hash_including_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+module RR
+  module WildcardMatchers
+    describe HashIncluding do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        subject { described_class.new({:foo => 'x'}) }
+
+        it "returns true when given object is a copy of this HashIncluding" do
+          matcher2 = described_class.new({:foo => 'x'})
+          should wildcard_match(matcher2)
+        end
+
+        it "returns true when given hash is contained within expected hash" do
+          should wildcard_match({:foo => 'x', :bar => 'y'})
+        end
+
+        it "returns false when given object is not a Hash" do
+          should_not wildcard_match('whatever')
+          should_not wildcard_match(:whatever)
+          should_not wildcard_match([1, 2, 3])
+        end
+
+        it "returns false when given object is a hash but is not contained within expected hash" do
+          should_not wildcard_match({:fiz => 'buz'})
+        end
+      end
+
+      describe '#==' do
+        subject { described_class.new({:foo => 'x'}) }
+
+        it "returns true when given object is a copy of this HashIncluding" do
+          matcher2 = described_class.new({:foo => 'x'})
+          should equal_match(matcher2)
+        end
+
+        it "returns false when it is a HashIncluding but not with the same hash" do
+          matcher2 = described_class.new({:x => 'y'})
+          should_not equal_match(matcher2)
+        end
+
+        it "returns false even when given a hash that wildcard matches this HashIncluding" do
+          should_not equal_match({:foo => 'x'})
+        end
+
+        it "returns false when not given a HashIncluding whatsoever" do
+          should_not equal_match(:something_else)
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          matcher = described_class.new({:foo => 'x', :bar => 'y'})
+          str = matcher.inspect
+          expect(str).to include("hash_including(")
+          expect(str).to include(':foo=>"x"')
+          expect(str).to include(':bar=>"y"')
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/is_a_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+module RR
+  module WildcardMatchers
+    describe IsA do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        subject { described_class.new(Symbol) }
+
+        it "returns true when given IsA is a copy of this IsA" do
+          matcher2 = described_class.new(Symbol)
+          should wildcard_match(matcher2)
+        end
+
+        it "returns true when given an object that is is_a?(klass)" do
+          should wildcard_match(:a_symbol)
+        end
+
+        it "returns false if not given an object that is is_a?(klass)" do
+          should_not wildcard_match('a string')
+        end
+      end
+
+      describe '#==' do
+        subject { described_class.new(Symbol) }
+
+        it "returns true when given IsA is a copy of this IsA" do
+          matcher2 = described_class.new(Symbol)
+          should equal_match(matcher2)
+        end
+
+        it "returns false when given IsA is not a copy of this IsA" do
+          matcher2 = described_class.new(String)
+          should_not equal_match(matcher2)
+        end
+
+        it "returns false even when given an object that wildcard matches this IsA" do
+          should_not equal_match(:something_else)
+        end
+
+        it "returns false when not given an IsA whatsoever" do
+          should_not equal_match([1, 2, 3])
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          matcher = described_class.new(Symbol)
+          expect(matcher.inspect).to eq "is_a(Symbol)"
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/numeric_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module WildcardMatchers
+    describe Numeric do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        it "returns true when given Numeric is a copy of this Numeric" do
+          matcher2 = described_class.new
+          should wildcard_match(matcher2)
+        end
+
+        it "returns true when given a Numeric" do
+          should wildcard_match(99)
+        end
+
+        it "returns false otherwise" do
+          should_not wildcard_match(:not_a_numeric)
+        end
+      end
+
+      describe '#==' do
+        it "returns true when given Numeric is a copy of this Numeric" do
+          matcher2 = described_class.new
+          should equal_match(matcher2)
+        end
+
+        it "returns false even when given an object that wildcard matches this Numeric" do
+          should_not equal_match(99)
+        end
+
+        it "returns false when not a Numeric whatsoever" do
+          should_not equal_match(:something_else)
+        end
+      end
+
+      describe "#inspect" do
+        it "returns the correct string" do
+          matcher = described_class.new
+          expect(matcher.inspect).to eq "numeric"
+        end
+      end
+    end
+  end
+end

data/spec/suites/rspec_2/unit/wildcard_matchers/satisfy_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+module RR
+  module WildcardMatchers
+    describe Satisfy do
+      include WildcardMatcherMatchers
+
+      describe '#wildcard_match?' do
+        let(:expectation_proc) { lambda {|v| v == 'x' } }
+        subject { described_class.new(expectation_proc) }
+
+        it "returns true if given Satisfy is a copy of this Satisfy" do
+          matcher2 = described_class.new(expectation_proc)
+          should wildcard_match(matcher2)
+        end
+
+        it "returns true if the given object matches the block" do
+          should wildcard_match('x')
+        end
+
+        it "returns false otherwise" do
+          should_not wildcard_match('y')
+        end
+      end
+
+      describe '#==' do
+        let(:expectation_proc) { lambda {|v| v == 'x' } }
+        subject { described_class.new(expectation_proc) }
+
+        it "returns true if given Satisfy is a copy of this Satisfy" do
+          matcher2 = described_class.new(expectation_proc)
+          should equal_match(matcher2)
+        end
+
+        it "returns false if given Satisfy is not a copy of this Satisfy" do
+          matcher2 = described_class.new(lambda {|v| })
+          should_not equal_match(matcher2)
+        end
+
+        it "returns false even when given an object that wildcard matches this Satisfy" do
+          should_not equal_match('x')
+        end
+
+        it "returns false when given object isn't even a Satisfy" do
+          should_not equal_match(:something_else)
+        end
+      end
+
+      describe '#inspect' do
+        it "returns the correct string" do
+          matcher = Satisfy.new(lambda {})
+          expect(matcher.inspect).to eq "satisfy { ... }"
+        end
+      end
+    end
+  end
+end