remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "failing MockArgumentMatchers" do
+      before(:each) do
+        @double = double("double")
+        @reporter = double("reporter").as_null_object
+      end
+
+      after(:each) do
+        @double.rspec_reset
+      end
+
+      it "rejects non boolean" do
+        @double.should_receive(:random_call).with(boolean())
+        expect do
+          @double.random_call("false")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non numeric" do
+        @double.should_receive(:random_call).with(an_instance_of(Numeric))
+        expect do
+          @double.random_call("1")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non string" do
+        @double.should_receive(:random_call).with(an_instance_of(String))
+        expect do
+          @double.random_call(123)
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects goose when expecting a duck" do
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted string" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails for a hash w/ wrong values" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call(:a => "b", :c => "e")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+
+      it "fails for a hash w/ wrong keys" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call("a" => "b", "c" => "d")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+
+      it "matches against a Matcher" do
+        expect do
+          @double.should_receive(:msg).with(equal(3))
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+      end
+
+      it "fails no_args with one arg" do
+        expect do
+          @double.should_receive(:msg).with(no_args)
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+      end
+
+      it "fails hash_including with missing key" do
+         expect do
+           @double.should_receive(:msg).with(hash_including(:a => 1))
+           @double.msg({})
+         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+      end
+
+      it "fails with block matchers" do
+        expect do
+          @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
+          @double.msg :no_msg_for_you
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashExcludingMatcher do
+        
+        it "describes itself properly" do
+          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
+        end      
+
+        describe "passing" do
+          it "matches a hash without the specified key" do
+            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
+          end
+          
+          it "matches a hash with the specified key, but different value" do
+            expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
+          end
+                    
+          it "matches a hash without the specified key, given as anything()" do
+            expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches an empty hash" do
+            expect(hash_not_including(:a)).to eq({})
+          end
+          
+          it "matches a hash without any of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
+          end
+          
+        end
+        
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_not_including(:a => 1)).not_to eq 1
+          end
+          
+          it "does not match a hash with a specified key" do
+            expect(hash_not_including(:b)).not_to eq(:b => 2)
+          end
+          
+          it "does not match a hash with the specified key/value pair" do
+            expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
+          end
+          
+          it "does not match a hash with the specified key" do
+            expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
+          end
+          
+          it "does not match a hash with one of the specified keys" do
+            expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
+          end
+          
+          it "does not match a hash with some of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
+          end
+          
+          it "does not match a hash with one key/value pair included" do
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashIncludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+        end
+
+        describe "passing" do
+          it "matches the same hash" do
+            expect(hash_including(:a => 1)).to eq({:a => 1})
+          end
+
+          it "matches a hash with extra stuff" do
+            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
+          end
+
+          describe "when matching against other matchers" do
+            it "matches an int against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches a string against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
+            end
+          end
+
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "matches if the key is present" do
+              expect(hash_including(:a)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if more keys are present" do
+              expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
+            end
+
+            it "matches a string against a given key" do
+              expect(hash_including(:a)).to eq({:a => "1", :b => 2})
+            end
+
+            it "matches if passed one key and one key/value pair" do
+              expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if passed many keys and one key/value pair" do
+              expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
+            end
+
+            it "matches if passed many keys and many key/value pairs" do
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
+            end
+          end
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_including(:a => 1)).not_to eq 1
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a => 1)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a)).not_to eq(:b => 2)
+          end
+
+          it "does not match an empty hash with a given key" do
+            expect(hash_including(:a)).not_to eq({})
+          end
+
+          it "does not match a hash with a missing key when one pair is matching" do
+            expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with an incorrect value" do
+            expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
+          end
+
+          it "does not match when values are nil but keys are different" do
+            expect(hash_including(:a => nil)).not_to eq(:b => nil)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe InstanceMethodStasher do
+      class ExampleClass
+        def hello
+          :hello_defined_on_class
+        end
+      end
+
+      def singleton_class_for(obj)
+        class << obj; self; end
+      end
+
+      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :hello_defined_on_singleton_class
+      end
+
+      it "stashes private instance methods" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+        singleton_class_for(obj).__send__(:private, :hello)
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        stashed_method.restore
+        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
+      end
+
+      it "only stashes methods directly defined on the given class, not its ancestors" do
+        obj = ExampleClass.new
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end;
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :overridden_hello
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/mock_ordering_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+
+    describe "ordering" do
+      before { @double = double("test double") }
+      after  { @double.rspec_reset }
+
+      it "passes when messages are received in order" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        @double.two
+        @double.three
+      end
+
+      it "passes when messages are received in order across objects" do
+        a = double("a")
+        b = double("b")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        b.two
+        a.three
+      end
+
+      it "fails when messages are received out of order (2nd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        expect {
+          @double.two
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        expect {
+          @double.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 2nd)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        expect {
+          @double.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are out of order across objects" do
+        a = double("test double")
+        b = double("another test double")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        expect {
+          a.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+        a.rspec_reset
+        b.rspec_reset
+      end
+
+      it "ignores order of non ordered messages" do
+        @double.should_receive(:ignored_0)
+        @double.should_receive(:ordered_1).ordered
+        @double.should_receive(:ignored_1)
+        @double.should_receive(:ordered_2).ordered
+        @double.should_receive(:ignored_2)
+        @double.should_receive(:ignored_3)
+        @double.should_receive(:ordered_3).ordered
+        @double.should_receive(:ignored_4)
+        @double.ignored_3
+        @double.ordered_1
+        @double.ignored_0
+        @double.ordered_2
+        @double.ignored_4
+        @double.ignored_2
+        @double.ordered_3
+        @double.ignored_1
+        @double.rspec_verify
+      end
+
+      it "supports duplicate messages" do
+        @double.should_receive(:a).ordered
+        @double.should_receive(:b).ordered
+        @double.should_receive(:a).ordered
+
+        @double.a
+        @double.b
+        @double.a
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-2.12.2/spec/rspec/mocks/mock_space_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+module RSpec
+  module Mocks
+    describe Space do
+      before :each do
+        @space = RSpec::Mocks::Space.new
+        klazz = Class.new do
+          def rspec_verify
+            @verified = true
+          end
+          def verified?
+            @verified
+          end
+          def rspec_reset
+            @reset = true
+          end
+          def reset?
+            @reset
+          end
+        end
+        @m1 = klazz.new
+        @m2 = klazz.new
+      end
+      it "verifies all mocks within" do
+        @space.add(@m1)
+        @space.add(@m2)
+        @space.verify_all
+        expect(@m1).to be_verified
+        expect(@m2).to be_verified
+      end
+      it "resets all mocks within" do
+        @space.add(m1 = double("mock1"))
+        @space.add(m2 = double("mock2"))
+        m1.should_receive(:rspec_reset)
+        m2.should_receive(:rspec_reset)
+        @space.reset_all
+      end
+      it "clears internal mocks on reset_all" do
+        @space.add(double("mock"))
+        @space.reset_all
+        expect(@space.instance_eval { receivers.empty? }).to be_true
+      end
+      it "resets the ordering" do
+        @space.reset_all
+        expect(@space.expectation_ordering).to be_empty
+      end
+      it "only adds an instance once" do
+        @space.add(m1 = double("mock1"))
+        @space.add(m1)
+        m1.should_receive(:rspec_verify)
+        @space.verify_all
+      end
+    end
+  end
+end
+