rr 1.1.1.rc1 → 1.1.1

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

@@ -1,117 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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