remq 0.0.1a → 0.0.3

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "a mock" do
+      before(:each) do
+        @mock = double("mock").as_null_object
+      end
+      it "answers false for received_message? when no messages received" do
+        expect(@mock.received_message?(:message)).to be_false
+      end
+      it "answers true for received_message? when message received" do
+        @mock.message
+        expect(@mock.received_message?(:message)).to be_true
+      end
+      it "answers true for received_message? when message received with correct args" do
+        @mock.message 1,2,3
+        expect(@mock.received_message?(:message, 1,2,3)).to be_true
+      end
+      it "answers false for received_message? when message received with incorrect args" do
+        @mock.message 1,2,3
+        expect(@mock.received_message?(:message, 1,2)).to be_false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Serialization do
+
+      class SerializableObject < Struct.new(:foo, :bar); end
+
+      class SerializableMockProxy
+        attr_reader :mock_proxy
+
+        def initialize(mock_proxy)
+          @mock_proxy = mock_proxy
+        end
+
+        def ==(other)
+          other.class == self.class && other.mock_proxy == mock_proxy
+        end
+      end
+
+      def self.with_yaml_loaded(&block)
+        context 'with YAML loaded' do
+          module_eval(&block)
+        end
+      end
+
+      def self.without_yaml_loaded(&block)
+        context 'without YAML loaded' do
+          before do
+            # We can't really unload yaml, but we can fake it here...
+            hide_const("YAML")
+            Struct.class_eval do
+              alias __old_to_yaml to_yaml
+              undef to_yaml
+            end
+          end
+
+          module_eval(&block)
+
+          after do
+            Struct.class_eval do
+              alias to_yaml __old_to_yaml
+              undef __old_to_yaml
+            end
+          end
+        end
+      end
+
+      let(:serializable_object) { RSpec::Mocks::SerializableObject.new(7, "something") }
+
+      def set_stub
+        serializable_object.stub(:bazz => 5)
+      end
+
+      shared_examples_for 'normal YAML serialization' do
+        it 'serializes to yaml the same with and without stubbing, using #to_yaml' do
+          expect { set_stub }.to_not change { serializable_object.to_yaml }
+        end
+
+        it 'serializes to yaml the same with and without stubbing, using YAML.dump' do
+          expect { set_stub }.to_not change { ::YAML.dump(serializable_object) }
+        end
+      end
+
+      with_yaml_loaded do
+        compiled_with_psych = begin
+          require 'psych'
+          true
+        rescue LoadError
+          false
+        end
+
+        if compiled_with_psych
+          context 'using Syck as the YAML engine' do
+            before(:each) { ::YAML::ENGINE.yamler = 'syck' }
+            it_behaves_like 'normal YAML serialization'
+          end
+
+          context 'using Psych as the YAML engine' do
+            before(:each) { ::YAML::ENGINE.yamler = 'psych' }
+            it_behaves_like 'normal YAML serialization'
+          end
+        else
+          it_behaves_like 'normal YAML serialization'
+        end
+      end
+
+      without_yaml_loaded do
+        it 'does not add #to_yaml to the stubbed object' do
+          expect(serializable_object).not_to respond_to(:to_yaml)
+          set_stub
+          expect(serializable_object).not_to respond_to(:to_yaml)
+        end
+      end
+
+      it 'marshals the same with and without stubbing' do
+        expect { set_stub }.to_not change { Marshal.dump(serializable_object) }
+      end
+
+      describe "an object that has its own mock_proxy instance variable" do
+        let(:serializable_object) { RSpec::Mocks::SerializableMockProxy.new(:my_mock_proxy) }
+
+        it 'does not interfere with its marshalling' do
+          marshalled_copy = Marshal.load(Marshal.dump(serializable_object))
+          expect(marshalled_copy).to eq serializable_object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+
+    describe "only stashing the original method" do
+      let(:klass) do
+        Class.new do
+          def self.foo(arg)
+            :original_value
+          end
+        end
+      end
+
+      it "keeps the original method intact after multiple expectations are added on the same method" do
+        klass.should_receive(:foo).with(:fizbaz).and_return(:wowwow)
+        klass.should_receive(:foo).with(:bazbar).and_return(:okay)
+
+        klass.foo(:fizbaz)
+        klass.foo(:bazbar)
+        klass.rspec_verify
+
+        klass.rspec_reset
+        expect(klass.foo(:yeah)).to equal(:original_value)
+      end
+    end
+
+    describe "when a class method is aliased on a subclass and the method is mocked" do
+      let(:klass) do
+        Class.new do
+          class << self
+            alias alternate_new new
+          end
+        end
+      end
+
+      it "restores the original aliased public method" do
+        klass = Class.new do
+          class << self
+            alias alternate_new new
+          end
+        end
+
+        klass.should_receive(:alternate_new)
+        expect(klass.alternate_new).to be_nil
+
+        klass.rspec_verify
+
+        klass.rspec_reset
+        expect(klass.alternate_new).to be_an_instance_of(klass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "A chained method stub" do
+      let(:object) { Object.new }
+
+      context "with one method in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining only one method call" do
+            object.stub_chain(:msg1).and_return(:return_value)
+            expect(object.msg1).to equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            object.stub_chain(:msg1) { :return_value }
+            expect(object.msg1).to equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            object.stub_chain(:msg1 => :return_value)
+            expect(object.msg1).to equal(:return_value)
+          end
+        end
+      end
+
+      context "with two methods in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining two method calls" do
+            object.stub_chain(:msg1, :msg2).and_return(:return_value)
+            expect(object.msg1.msg2).to equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            object.stub_chain(:msg1, :msg2) { :return_value }
+            expect(object.msg1.msg2).to equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            object.stub_chain(:msg1, :msg2 => :return_value)
+            expect(object.msg1.msg2).to equal(:return_value)
+          end
+        end
+      end
+
+      context "with four methods in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining two method calls" do
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
+          end
+        end
+
+        context "using a block" do
+          it "returns the correct value" do
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
+          end
+        end
+
+        context "using a hash" do
+          it "returns the value of the key/value pair" do
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
+          end
+        end
+
+        context "using a hash with a string key" do
+          it "returns the value of the key/value pair" do
+            object.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
+          end
+        end
+      end
+
+      it "returns expected value from chaining four method calls" do
+        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+        expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
+      end
+
+      context "with messages shared across multiple chains" do
+        context "using and_return" do
+          context "starting with the same message" do
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              object.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
+
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg1.msg2.msg4).to equal(:second)
+            end
+          end
+
+          context "starting with the different messages" do
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              object.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
+
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg4.msg2.msg3).to equal(:second)
+            end
+          end
+        end
+
+        context "using => value" do
+          context "starting with the same message" do
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3 => :first)
+              object.stub_chain(:msg1, :msg2, :msg4 => :second)
+
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg1.msg2.msg4).to equal(:second)
+            end
+          end
+
+          context "starting with different messages" do
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3 => :first)
+              object.stub_chain(:msg4, :msg2, :msg3 => :second)
+
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg4.msg2.msg3).to equal(:second)
+            end
+          end
+        end
+      end
+
+      it "returns expected value when chain is a dot separated string, like stub_chain('msg1.msg2.msg3')" do
+        object.stub_chain("msg1.msg2.msg3").and_return(:return_value)
+        expect(object.msg1.msg2.msg3).to equal(:return_value)
+      end
+
+      it "returns expected value from two chains with shared messages at the beginning" do
+        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        object.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
+
+        expect(object.msg1.msg2.msg3.msg4).to equal(:first)
+        expect(object.msg1.msg2.msg3.msg5).to equal(:second)
+      end
+
+      it "handles private instance methods (like Object#select) in the middle of a chain" do
+        object.stub_chain(:msg1, :select, :msg3 => 'answer')
+        expect(object.msg1.select.msg3).to eq 'answer'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stub implementation" do
+      describe "with no args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) { :bar }
+          expect(obj.foo).to eq :bar
+        end
+      end
+
+      describe "with one arg" do
+        it "execs the block with that arg when called" do
+          obj = stub()
+          obj.stub(:foo) {|given| given}
+          expect(obj.foo(:bar)).to eq :bar
+        end
+      end
+
+      describe "with variable args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) {|*given| given.first}
+          expect(obj.foo(:bar)).to eq :bar
+        end
+      end
+    end
+
+
+    describe "unstub implementation" do
+      it "replaces the stubbed method with the original method" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo)
+        obj.unstub(:foo)
+        expect(obj.foo).to eq :original
+      end
+
+      it "removes all stubs with the supplied method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        expect(obj.foo).to eq :original
+      end
+
+      it "does not remove any expectations with the same method name" do
+        obj = Object.new
+        def obj.foo; :original; end
+        obj.should_receive(:foo).with(3).and_return(:three)
+        obj.stub(:foo).with(1)
+        obj.stub(:foo).with(2)
+        obj.unstub(:foo)
+        expect(obj.foo(3)).to eq :three
+      end
+
+      it "restores the correct implementations when stubbed and unstubbed on a parent and child class" do
+        parent = Class.new
+        child  = Class.new(parent)
+
+        parent.stub(:new)
+        child.stub(:new)
+        parent.unstub(:new)
+        child.unstub(:new)
+
+        expect(parent.new).to be_an_instance_of parent
+        expect(child.new).to be_an_instance_of child
+      end
+
+      it "raises a MockExpectationError if the method has not been stubbed" do
+        obj = Object.new
+        expect {
+          obj.unstub(:foo)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "A method stub" do
+      before(:each) do
+        @class = Class.new do
+          class << self
+            def existing_class_method
+              existing_private_class_method
+            end
+
+            private
+            def existing_private_class_method
+              :original_value
+            end
+          end
+
+          def existing_instance_method
+            existing_private_instance_method
+          end
+
+          private
+          def existing_private_instance_method
+            :original_value
+          end
+        end
+        @instance = @class.new
+        @stub = Object.new
+      end
+
+      [:stub!, :stub].each do |method|
+        describe "using #{method}" do
+          it "returns declared value when message is received" do
+            @instance.send(method, :msg).and_return(:return_value)
+            expect(@instance.msg).to equal(:return_value)
+            @instance.rspec_verify
+          end
+        end
+      end
+
+      it "instructs an instance to respond_to the message" do
+        @instance.stub(:msg)
+        expect(@instance).to respond_to(:msg)
+      end
+
+      it "instructs a class object to respond_to the message" do
+        @class.stub(:msg)
+        expect(@class).to respond_to(:msg)
+      end
+
+      it "ignores when expected message is received with no args" do
+        @instance.stub(:msg)
+        @instance.msg
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "ignores when message is received with args" do
+        @instance.stub(:msg)
+        @instance.msg(:an_arg)
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "ignores when expected message is not received" do
+        @instance.stub(:msg)
+        expect do
+          @instance.rspec_verify
+        end.not_to raise_error
+      end
+
+      it "handles multiple stubbed methods" do
+        @instance.stub(:msg1 => 1, :msg2 => 2)
+        expect(@instance.msg1).to eq(1)
+        expect(@instance.msg2).to eq(2)
+      end
+
+      describe "#rspec_reset" do
+        it "removes stubbed methods that didn't exist" do
+          @instance.stub(:non_existent_method)
+          @instance.rspec_reset
+          expect(@instance).not_to respond_to(:non_existent_method)
+        end
+
+        it "restores existing instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_instance_method) { :stub_value }
+          @instance.rspec_reset
+          expect(@instance.existing_instance_method).to eq(:original_value)
+        end
+
+        it "restores existing private instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_private_instance_method) { :stub_value }
+          @instance.rspec_reset
+          expect(@instance.send(:existing_private_instance_method)).to eq(:original_value)
+        end
+
+        it "restores existing class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_class_method) { :stub_value }
+          @class.rspec_reset
+          expect(@class.existing_class_method).to eq(:original_value)
+        end
+
+        it "restores existing private class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_private_class_method) { :stub_value }
+          @class.rspec_reset
+          expect(@class.send(:existing_private_class_method)).to eq(:original_value)
+        end
+
+        it "does not remove existing methods that have been stubbed twice" do
+          @instance.stub(:existing_instance_method)
+          @instance.stub(:existing_instance_method)
+
+          @instance.rspec_reset
+
+          expect(@instance.existing_instance_method).to eq(:original_value)
+        end
+
+        it "correctly restores the visibility of methods whose visibility has been tweaked on the singleton class" do
+          # hello is a private method when mixed in, but public on the module
+          # itself
+          mod = Module.new {
+            extend self
+            def hello; :hello; end
+
+            private :hello
+            class << self; public :hello; end;
+          }
+
+          expect(mod.hello).to eq(:hello)
+
+          mod.stub(:hello) { :stub }
+          mod.rspec_reset
+
+          expect(mod.hello).to eq(:hello)
+        end
+      end
+
+      it "returns values in order to consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
+      end
+
+      it "keeps returning last value in consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
+      end
+
+      it "yields a specified object" do
+        @instance.stub(:method_that_yields).and_yield(:yielded_obj)
+        current_value = :value_before
+        @instance.method_that_yields {|val| current_value = val}
+        expect(current_value).to eq :yielded_obj
+        @instance.rspec_verify
+      end
+
+      it "yields multiple times with multiple calls to and_yield" do
+        @instance.stub(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @instance.method_that_yields_multiple_times {|val| current_value << val}
+        expect(current_value).to eq [:yielded_value, :another_value]
+        @instance.rspec_verify
+      end
+
+      it "yields a specified object and return another specified object" do
+        yielded_obj = double("my mock")
+        yielded_obj.should_receive(:foo).with(:bar)
+        @instance.stub(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        expect(@instance.method_that_yields_and_returns { |o| o.foo :bar }).to eq :baz
+      end
+
+      it "throws when told to" do
+        @stub.stub(:something).and_throw(:up)
+        expect { @stub.something }.to throw_symbol(:up)
+      end
+
+      it "throws with argument when told to" do
+        @stub.stub(:something).and_throw(:up, 'high')
+        expect { @stub.something }.to throw_symbol(:up, 'high')
+      end
+
+      it "overrides a pre-existing method" do
+        @stub.stub(:existing_instance_method).and_return(:updated_stub_value)
+        expect(@stub.existing_instance_method).to eq :updated_stub_value
+      end
+
+      it "overrides a pre-existing stub" do
+        @stub.stub(:foo) { 'bar' }
+        @stub.stub(:foo) { 'baz' }
+        expect(@stub.foo).to eq 'baz'
+      end
+
+      it "allows a stub and an expectation" do
+        @stub.stub(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "calculates return value by executing block passed to #and_return" do
+        @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        expect(@stub.something("a","b","c")).to eq "cba"
+        @stub.rspec_verify
+      end
+    end
+
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub(:foo).with("bar")
+      end
+
+      it "does not complain if not called" do
+      end
+
+      it "does not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "complains if called with no arg" do
+        expect {
+          @stub.foo
+        }.to raise_error(/received :foo with unexpected arguments/)
+      end
+
+      it "complains if called with other arg", :github_issue => [123,147] do
+        expect {
+          @stub.foo("other")
+        }.to raise_error(/received :foo with unexpected arguments.*Please stub a default value/m)
+      end
+
+      it "does not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "complains if also mocked w/ different args AND called w/ a 3rd set of args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+        expect {
+          @stub.foo("other")
+        }.to raise_error
+      end
+
+      it "supports options" do
+        @stub.stub(:foo, :expected_from => "bar")
+      end
+    end
+
+  end
+end