remq 0.0.1a → 0.0.3

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

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "a double _not_ acting as a null object" do
+      before(:each) do
+        @double = double('non-null object')
+      end
+
+      it "says it does not respond to messages it doesn't understand" do
+        expect(@double).not_to respond_to(:foo)
+      end
+
+      it "says it responds to messages it does understand" do
+        @double.stub(:foo)
+        expect(@double).to respond_to(:foo)
+      end
+
+      it "raises an error when interpolated in a string as an integer" do
+        # Not sure why, but 1.9.2 (but not JRuby --1.9) raises a different
+        # error than 1.8.7 and 1.9.3...
+        expected_error = (RUBY_VERSION == '1.9.2' && RUBY_PLATFORM !~ /java/) ?
+                         RSpec::Mocks::MockExpectationError :
+                         TypeError
+
+        expect { "%i" % @double }.to raise_error(expected_error)
+      end
+    end
+
+    describe "a double acting as a null object" do
+      before(:each) do
+        @double = double('null object').as_null_object
+      end
+
+      it "says it responds to everything" do
+        expect(@double).to respond_to(:any_message_it_gets)
+      end
+
+      it "allows explicit stubs" do
+        @double.stub(:foo) { "bar" }
+        expect(@double.foo).to eq("bar")
+      end
+
+      it "allows explicit expectation" do
+        @double.should_receive(:something)
+        @double.something
+      end
+
+      it 'continues to return self from an explicit expectation' do
+        @double.should_receive(:bar)
+        expect(@double.foo.bar).to be(@double)
+      end
+
+      it 'returns an explicitly stubbed value from an expectation with no implementation' do
+        @double.stub(:foo => "bar")
+        @double.should_receive(:foo)
+        expect(@double.foo).to eq("bar")
+      end
+
+      it "fails verification when explicit exception not met" do
+        expect {
+          @double.should_receive(:something)
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "ignores unexpected methods" do
+        @double.random_call("a", "d", "c")
+        @double.rspec_verify
+      end
+
+      it "allows expected message with different args first" do
+        @double.should_receive(:message).with(:expected_arg)
+        @double.message(:unexpected_arg)
+        @double.message(:expected_arg)
+      end
+
+      it "allows expected message with different args second" do
+        @double.should_receive(:message).with(:expected_arg)
+        @double.message(:expected_arg)
+        @double.message(:unexpected_arg)
+      end
+
+      it "can be interpolated in a string as an integer" do
+        # This form of string interpolation calls
+        # @double.to_int.to_int.to_int...etc until it gets an integer,
+        # and thus gets stuck in an infinite loop unless our double
+        # returns an int value from #to_int.
+        expect(("%i" % @double)).to eq("0")
+      end
+    end
+
+    describe "#as_null_object" do
+      it "sets the object to null_object" do
+        obj = double('anything').as_null_object
+        expect(obj).to be_null_object
+      end
+    end
+
+    describe "#null_object?" do
+      it "defaults to false" do
+        obj = double('anything')
+        expect(obj).not_to be_null_object
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "#once" do
+      before(:each) do
+        @double = double
+      end
+
+      it "passes when called once" do
+        @double.should_receive(:do_something).once
+        @double.do_something
+        @double.rspec_verify
+      end
+
+      it "passes when called once with specified args" do
+        @double.should_receive(:do_something).once.with("a", "b", "c")
+        @double.do_something("a", "b", "c")
+        @double.rspec_verify
+      end
+
+      it "passes when called once with unspecified args" do
+        @double.should_receive(:do_something).once
+        @double.do_something("a", "b", "c")
+        @double.rspec_verify
+      end
+
+      it "fails when called with wrong args" do
+        @double.should_receive(:do_something).once.with("a", "b", "c")
+        expect {
+          @double.do_something("d", "e", "f")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        @double.rspec_reset
+      end
+
+      it "fails fast when called twice" do
+        @double.should_receive(:do_something).once
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when not called" do
+        @double.should_receive(:do_something).once
+        expect {
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "calling :should_receive with an options hash" do
+      it "reports the file and line submitted with :expected_from" do
+        begin
+          mock = RSpec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
+          mock.rspec_verify
+        rescue Exception => e
+        ensure
+          expect(e.backtrace.to_s).to match /\/path\/to\/blah.ext:37/m
+        end
+      end
+
+      it "uses the message supplied with :message" do
+        expect {
+          m = RSpec::Mocks::Mock.new("a mock")
+          m.should_receive(:message, :message => "recebi nada")
+          m.rspec_verify
+        }.to raise_error("recebi nada")
+      end
+
+      it "uses the message supplied with :message after a similar stub" do
+        expect {
+          m = RSpec::Mocks::Mock.new("a mock")
+          m.stub(:message)
+          m.should_receive(:message, :message => "from mock")
+          m.rspec_verify
+        }.to raise_error("from mock")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "using a Partial Mock," do
+      let(:object) { Object.new }
+
+      it "names the class in the failure message" do
+        object.should_receive(:foo)
+        expect do
+          object.rspec_verify
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
+      end
+
+      it "names the class in the failure message when expectation is on class" do
+        Object.should_receive(:foo)
+        expect {
+          Object.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
+      end
+
+      it "does not conflict with @options in the object" do
+        object.instance_eval { @options = Object.new }
+        object.should_receive(:blah)
+        object.blah
+      end
+
+      it "should_not_receive mocks out the method" do
+        object.should_not_receive(:fuhbar)
+        expect {
+          object.fuhbar
+        }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          /expected\: 0 times\n    received\: 1 time/
+        )
+      end
+
+      it "should_not_receive returns a negative message expectation" do
+        expect(object.should_not_receive(:foobar)).to be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
+      end
+
+      it "should_receive mocks out the method" do
+        object.should_receive(:foobar).with(:test_param).and_return(1)
+        expect(object.foobar(:test_param)).to equal(1)
+      end
+
+      it "should_receive handles a hash" do
+        object.should_receive(:foobar).with(:key => "value").and_return(1)
+        expect(object.foobar(:key => "value")).to equal(1)
+      end
+
+      it "should_receive handles an inner hash" do
+        hash = {:a => {:key => "value"}}
+        object.should_receive(:foobar).with(:key => "value").and_return(1)
+        expect(object.foobar(hash[:a])).to equal(1)
+      end
+
+      it "should_receive returns a message expectation" do
+        expect(object.should_receive(:foobar)).to be_kind_of(RSpec::Mocks::MessageExpectation)
+        object.foobar
+      end
+
+      it "should_receive verifies method was called" do
+        object.should_receive(:foobar).with(:test_param).and_return(1)
+        expect {
+          object.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "should_receive also takes a String argument" do
+        object.should_receive('foobar')
+        object.foobar
+      end
+
+      it "should_not_receive also takes a String argument" do
+        object.should_not_receive('foobar')
+        expect {
+          object.foobar
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "uses reports nil in the error message" do
+        allow_message_expectations_on_nil
+
+        _nil = nil
+        _nil.should_receive(:foobar)
+        expect {
+          _nil.rspec_verify
+        }.to raise_error(
+          RSpec::Mocks::MockExpectationError,
+          %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|
+        )
+      end
+
+      it "includes the class name in the error when mocking a class method that is called an extra time with the wrong args" do
+        klass = Class.new do
+          def self.inspect
+            "MyClass"
+          end
+        end
+
+        klass.should_receive(:bar).with(1)
+        klass.bar(1)
+
+        expect {
+          klass.bar(2)
+        }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
+      end
+    end
+
+    describe "Using a partial mock on a proxy object", :if => defined?(::BasicObject) do
+      let(:proxy_class) do
+        Class.new(::BasicObject) do
+          def initialize(target)
+            @target = target
+          end
+
+          def proxied?
+            true
+          end
+
+          def method_missing(*a)
+            @target.send(*a)
+          end
+        end
+      end
+
+      let(:instance) { proxy_class.new(Object.new) }
+
+      it 'works properly' do
+        instance.should_receive(:proxied?).and_return(false)
+        expect(instance).not_to be_proxied
+      end
+    end
+
+    describe "Partially mocking an object that defines ==, after another mock has been defined" do
+      before(:each) do
+        stub("existing mock", :foo => :foo)
+      end
+
+      let(:klass) do
+        Class.new do
+          attr_reader :val
+          def initialize(val)
+            @val = val
+          end
+
+          def ==(other)
+            @val == other.val
+          end
+        end
+      end
+
+      it "does not raise an error when stubbing the object" do
+        o = klass.new :foo
+        expect { o.stub(:bar) }.not_to raise_error(NoMethodError)
+      end
+    end
+
+    describe "Method visibility when using partial mocks" do
+      let(:klass) do
+        Class.new do
+          def public_method
+            private_method
+            protected_method
+          end
+          protected
+          def protected_method; end
+          private
+          def private_method; end
+        end
+      end
+
+      let(:object) { klass.new }
+
+      it 'keeps public methods public' do
+        object.should_receive(:public_method)
+        expect(object.public_methods).to include_method(:public_method)
+        object.public_method
+      end
+
+      it 'keeps private methods private' do
+        object.should_receive(:private_method)
+        expect(object.private_methods).to include_method(:private_method)
+        object.public_method
+      end
+
+      it 'keeps protected methods protected' do
+        object.should_receive(:protected_method)
+        expect(object.protected_methods).to include_method(:protected_method)
+        object.public_method
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module RSpec::Mocks
+  describe "PartialMockUsingMocksDirectly" do
+    let(:klass) do
+      Class.new do
+        module MethodMissing
+          remove_method :method_missing rescue nil
+          def method_missing(m, *a, &b)
+            if m == :captured_by_method_missing
+              "response generated by method missing"
+            else
+              super(m, *a, &b)
+            end
+          end
+        end
+
+        extend MethodMissing
+        include MethodMissing
+
+        def existing_method
+          :original_value
+        end
+
+      end
+    end
+
+    let(:obj) { klass.new }
+
+    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
+    # specify "should clear expectations on verify" do
+    #     obj.should_receive(:msg)
+    #     obj.msg
+    #     obj.rspec_verify
+    #     expect {
+    #       obj.msg
+    #     }.to raise_error(NoMethodError)
+    #
+    # end
+    it "fails when expected message is not received" do
+      obj.should_receive(:msg)
+      expect {
+        obj.rspec_verify
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
+    end
+
+    it "fails when message is received with incorrect args" do
+      obj.should_receive(:msg).with(:correct_arg)
+      expect {
+        obj.msg(:incorrect_arg)
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
+      obj.msg(:correct_arg)
+    end
+
+    it "passes when expected message is received" do
+      obj.should_receive(:msg)
+      obj.msg
+      obj.rspec_verify
+    end
+
+    it "passes when message is received with correct args" do
+      obj.should_receive(:msg).with(:correct_arg)
+      obj.msg(:correct_arg)
+      obj.rspec_verify
+    end
+
+    it "restores the original method if it existed" do
+      expect(obj.existing_method).to equal(:original_value)
+      obj.should_receive(:existing_method).and_return(:mock_value)
+      expect(obj.existing_method).to equal(:mock_value)
+      obj.rspec_verify
+      expect(obj.existing_method).to equal(:original_value)
+    end
+
+    context "with an instance method handled by method_missing" do
+      it "restores the original behavior" do
+        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
+        obj.stub(:captured_by_method_missing) { "foo" }
+        expect(obj.captured_by_method_missing).to eq("foo")
+        obj.rspec_reset
+        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
+      end
+    end
+
+    context "with a class method handled by method_missing" do
+      it "restores the original behavior" do
+        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
+        klass.stub(:captured_by_method_missing) { "foo" }
+        expect(klass.captured_by_method_missing).to eq("foo")
+        klass.rspec_reset
+        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Methods do
+      before(:each) do
+        @double = double('double')
+        Kernel.stub(:warn)
+      end
+
+      after(:each) do
+        @double.rspec_verify
+      end
+
+      context "handling argument matchers" do
+        it "accepts true as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(true)
+        end
+
+        it "accepts false as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(false)
+        end
+
+        it "accepts fixnum as kind_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1)
+        end
+
+        it "accepts float as an_instance_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1.5)
+        end
+
+        it "accepts fixnum as instance_of(Fixnum)" do
+          @double.should_receive(:random_call).with(instance_of(Fixnum))
+          @double.random_call(1)
+        end
+
+        it "does NOT accept fixnum as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1)
+        end
+
+        it "does NOT accept float as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1.5)
+        end
+
+        it "accepts string as anything()" do
+          @double.should_receive(:random_call).with("a", anything(), "c")
+          @double.random_call("a", "whatever", "c")
+        end
+
+        it "matches duck type with one method" do
+          @double.should_receive(:random_call).with(duck_type(:length))
+          @double.random_call([])
+        end
+
+        it "matches duck type with two methods" do
+          @double.should_receive(:random_call).with(duck_type(:abs, :div))
+          @double.random_call(1)
+        end
+
+        it "matches no args against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call()
+        end
+
+        it "matches one arg against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call("a string")
+        end
+
+        it "matches no args against no_args()" do
+          @double.should_receive(:random_call).with(no_args)
+          @double.random_call()
+        end
+
+        it "matches hash with hash_including same hash" do
+          @double.should_receive(:random_call).with(hash_including(:a => 1))
+          @double.random_call(:a => 1)
+        end
+      end
+
+      context "handling block matchers" do
+        it "matches arguments against RSpec expectations" do
+          @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
+            expect(arg1).to eq 5
+            expect(arg2).to have_at_least(3).characters
+            expect(arg2).to have_at_most(10).characters
+            expect(arr.map {|i| i * 2}).to eq [2,4,6]
+            expect(rest).to eq [:fee, "fi", 4]
+          }
+          @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+        end
+
+        it "does not eval the block as the return value" do
+          eval_count = 0
+          @double.should_receive(:msg).with {|a| eval_count += 1}
+          @double.msg(:ignore)
+          expect(eval_count).to eq(1)
+        end
+      end
+
+      context "handling non-matcher arguments" do
+        it "matches non special symbol (can be removed when deprecated symbols are removed)" do
+          @double.should_receive(:random_call).with(:some_symbol)
+          @double.random_call(:some_symbol)
+        end
+
+        it "matches string against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call("abcde")
+        end
+
+        it "matches regexp against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call(/bcd/)
+        end
+
+        it "matches against a hash submitted and received by value" do
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by reference and received by value" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(opts)
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by value and received by reference" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "PreciseCounts" do
+      before(:each) do
+        @double = double("test double")
+      end
+
+      it "fails when exactly n times method is called less than n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails fast when exactly n times method is called more than n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when exactly n times method is never called" do
+        @double.should_receive(:do_something).exactly(3).times
+        expect {
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "passes if exactly n times method is called exactly n times" do
+        @double.should_receive(:do_something).exactly(3).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.rspec_verify
+      end
+
+      it "returns the value given by a block when the exactly once method is called" do
+        @double.should_receive(:to_s).exactly(:once) { "testing" }
+        expect(@double.to_s).to eq "testing"
+        @double.rspec_verify
+      end
+
+      it "passes mutiple calls with different args" do
+        @double.should_receive(:do_something).once.with(1)
+        @double.should_receive(:do_something).once.with(2)
+        @double.do_something(1)
+        @double.do_something(2)
+        @double.rspec_verify
+      end
+
+      it "passes multiple calls with different args and counts" do
+        @double.should_receive(:do_something).twice.with(1)
+        @double.should_receive(:do_something).once.with(2)
+        @double.do_something(1)
+        @double.do_something(2)
+        @double.do_something(1)
+        @double.rspec_verify
+      end
+    end
+  end
+end