opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-mocks/spec/rspec/mocks/space_spec.rb

@@ -0,0 +1,242 @@
+
+module RSpec::Mocks
+  RSpec.describe Space do
+    let(:space) { Space.new }
+    let(:dbl_1) { Object.new }
+    let(:dbl_2) { Object.new }
+
+    describe "#verify_all" do
+      it "verifies all mocks within" do
+        verifies = []
+
+        allow(space.proxy_for(dbl_1)).to receive(:verify) { verifies << :dbl_1 }
+        allow(space.proxy_for(dbl_2)).to receive(:verify) { verifies << :dbl_2 }
+
+        space.verify_all
+
+        expect(verifies).to match_array([:dbl_1, :dbl_2])
+      end
+
+      def define_singleton_method_on_recorder_for(klass, name, &block)
+        recorder = space.any_instance_recorder_for(klass)
+        (class << recorder; self; end).send(:define_method, name, &block)
+      end
+
+      it 'verifies all any_instance recorders within' do
+        klass_1, klass_2 = Class.new, Class.new
+
+        verifies = []
+
+        # We can't `stub` a method on the recorder because it defines its own `stub`...
+        define_singleton_method_on_recorder_for(klass_1, :verify) { verifies << :klass_1 }
+        define_singleton_method_on_recorder_for(klass_2, :verify) { verifies << :klass_2 }
+
+        space.verify_all
+
+        expect(verifies).to match_array([:klass_1, :klass_2])
+      end
+
+      it 'does not reset the proxies (as that should be delayed until reset_all)' do
+        proxy = space.proxy_for(dbl_1)
+        reset = false
+        (class << proxy; self; end).__send__(:define_method, :reset) { reset = true }
+
+        space.verify_all
+        expect(reset).to eq(false)
+      end
+    end
+
+    describe "#reset_all" do
+      it "resets all mocks within" do
+        resets = []
+
+        allow(space.proxy_for(dbl_1)).to receive(:reset) { resets << :dbl_1 }
+        allow(space.proxy_for(dbl_2)).to receive(:reset) { resets << :dbl_2 }
+
+        space.reset_all
+
+        expect(resets).to match_array([:dbl_1, :dbl_2])
+      end
+    end
+
+    describe "#proxies_of(klass)" do
+      it 'returns proxies' do
+        space.proxy_for("")
+        expect(space.proxies_of(String).map(&:class)).to eq([PartialDoubleProxy])
+      end
+
+      def create_generations
+        grandparent_class = Class.new
+        parent_class      = Class.new(grandparent_class)
+        child_class       = Class.new(parent_class)
+
+        grandparent = grandparent_class.new
+        parent      = parent_class.new
+        child       = child_class.new
+
+        return grandparent, parent, child
+      end
+
+      it 'returns only the proxies whose object is an instance of the given class' do
+        grandparent, parent, child = create_generations
+
+        space.proxy_for(grandparent)
+
+        parent_proxy = space.proxy_for(parent)
+        child_proxy  = space.proxy_for(child)
+
+        expect(space.proxies_of(parent.class)).to contain_exactly(parent_proxy, child_proxy)
+      end
+
+      it 'looks in the parent space for matching proxies' do
+        _, parent, child = create_generations
+
+        parent_proxy = space.proxy_for(parent)
+        subspace     = space.new_scope
+        child_proxy  = subspace.proxy_for(child)
+
+        expect(subspace.proxies_of(parent.class)).to contain_exactly(parent_proxy, child_proxy)
+      end
+    end
+
+    it 'tracks proxies in parent and child space separately' do
+      proxy1   = space.proxy_for(Object.new)
+      subspace = space.new_scope
+      proxy2   = subspace.proxy_for(Object.new)
+
+      expect(space.proxies.values).to include(proxy1)
+      expect(space.proxies.values).not_to include(proxy2)
+
+      expect(subspace.proxies.values).to include(proxy2)
+      expect(subspace.proxies.values).not_to include(proxy1)
+    end
+
+    it "only adds an instance once" do
+      m1 = double("mock1")
+
+      expect {
+        space.ensure_registered(m1)
+      }.to change { space.proxies }
+
+      expect {
+        space.ensure_registered(m1)
+      }.not_to change { space.proxies }
+    end
+
+    [:ensure_registered, :proxy_for].each do |method|
+      describe "##{method}" do
+        define_method :get_proxy do |space, object|
+          space.__send__(method, object)
+        end
+
+        it 'returns the proxy for the given object' do
+          obj1 = Object.new
+          obj2 = Object.new
+
+          expect(get_proxy(space, obj1)).to equal(get_proxy(space, obj1))
+          expect(get_proxy(space, obj2)).to equal(get_proxy(space, obj2))
+          expect(get_proxy(space, obj1)).not_to equal(get_proxy(space, obj2))
+        end
+
+        it 'can stil return a proxy from a parent context' do
+          proxy    = get_proxy(space, Object)
+          subspace = space.new_scope
+
+          expect(get_proxy(subspace, Object)).to equal(proxy)
+        end
+
+        it "does not store a parent's proxy in the child space" do
+          get_proxy(space, Object)
+          subspace = space.new_scope
+
+          expect {
+            get_proxy(subspace, Object)
+          }.not_to change { subspace.proxies }.from({})
+        end
+      end
+    end
+
+    describe "#registered?" do
+      it 'returns true if registered in this space' do
+        space.ensure_registered(Object)
+        expect(space).to be_registered(Object)
+      end
+
+      it 'returns true if registered in a parent space' do
+        space.ensure_registered(Object)
+        expect(space.new_scope).to be_registered(Object)
+      end
+
+      it 'returns false if not registered in this or a parent space' do
+        expect(space.new_scope).not_to be_registered(Object)
+      end
+    end
+
+    describe "#constant_mutator_for" do
+      it 'returns the mutator for the given const name' do
+        space = RSpec::Mocks.space
+        stub_const("Foo", 3)
+        stub_const("Bar", 4)
+
+        expect(space.constant_mutator_for("Foo")).to equal(space.constant_mutator_for("Foo"))
+        expect(space.constant_mutator_for("Bar")).to equal(space.constant_mutator_for("Bar"))
+        expect(space.constant_mutator_for("Foo")).not_to equal(space.constant_mutator_for("Bar"))
+      end
+
+      it 'can stil return a mutator from a parent context' do
+        space = RSpec::Mocks.space
+
+        stub_const("Foo", 3)
+        mutator = space.constant_mutator_for("Foo")
+
+        in_new_space_scope do
+          subspace = RSpec::Mocks.space
+          expect(subspace.constant_mutator_for("Foo")).to equal(mutator)
+        end
+      end
+    end
+
+    describe "#any_instance_recorder_for" do
+      it 'returns the recorder for the given class' do
+        expect(space.any_instance_recorder_for(String)).to equal(space.any_instance_recorder_for(String))
+        expect(space.any_instance_recorder_for(Symbol)).to equal(space.any_instance_recorder_for(Symbol))
+        expect(space.any_instance_recorder_for(String)).not_to equal(space.any_instance_recorder_for(Symbol))
+      end
+
+      it 'can stil return a recorder from a parent context' do
+        recorder = space.any_instance_recorder_for(String)
+        subspace = space.new_scope
+
+        expect(subspace.any_instance_recorder_for(String)).to equal(recorder)
+      end
+
+      it "does not store a parent's proxy in the child space" do
+        space.any_instance_recorder_for(String)
+        subspace = space.new_scope
+
+        expect {
+          subspace.any_instance_recorder_for(String)
+        }.not_to change { subspace.any_instance_recorders }.from({})
+      end
+    end
+
+    it 'can be diffed in a failure when it has references to an error generator via a proxy' do
+      space1 = Space.new
+      space2 = Space.new
+
+      space1.proxy_for("")
+      space2.proxy_for("")
+
+      expect {
+        expect(space1).to eq(space2)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Diff/)
+    end
+
+    def in_new_space_scope
+      RSpec::Mocks.setup
+      yield
+    ensure
+      RSpec::Mocks.teardown
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks/spy_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+RSpec.describe "the spy family of methods" do
+  describe "spy" do
+    it "responds to arbitrary methods" do
+      expect(spy.respond_to?(:foo)).to be true
+    end
+
+    it "takes a name" do
+      expect(spy(:bacon_bits).inspect).to include("bacon_bits")
+    end
+
+    it "records called methods" do
+      expect(spy.tap { |s| s.foo }).to have_received(:foo)
+    end
+
+    it "takes a hash of method names and return values" do
+      expect(spy(:foo => :bar).foo).to eq(:bar)
+    end
+
+    it "takes a name and a hash of method names and return values" do
+      expect(spy(:bacon_bits, :foo => :bar).foo).to eq(:bar)
+    end
+  end
+
+  shared_examples_for "a verifying spy with a foo method" do
+    it "responds to methods on the verified object" do
+      expect(subject.respond_to?(:foo)).to be true
+    end
+
+    it "does not respond to methods that are not on the verified object" do
+      expect(subject.respond_to?(:other_method)).to be false
+    end
+
+    it "records called methods" do
+      expect(subject.tap { |s| s.foo}).to have_received(:foo)
+    end
+
+    it 'fails fast when `have_received` is passed an undefined method name' do
+      expect {
+        expect(subject).to have_received(:bar)
+      }.to fail_matching("does not implement")
+    end
+
+    it 'fails fast when negative `have_received` is passed an undefined method name' do
+      expect {
+        expect(subject).to_not have_received(:bar)
+      }.to fail_matching("does not implement")
+    end
+  end
+
+  describe "instance_spy" do
+    context "when passing a class object" do
+      let(:the_class) do
+        Class.new do
+          def foo
+            3
+          end
+        end
+      end
+
+      subject { instance_spy(the_class) }
+
+      it_behaves_like "a verifying spy with a foo method"
+
+      it "takes a class and a hash of method names and return values" do
+        expect(instance_spy(the_class, :foo => :bar).foo).to eq(:bar)
+      end
+    end
+
+    context "passing a class by string reference" do
+      DummyClass = Class.new do
+        def foo
+          3
+        end
+      end
+
+      let(:the_class) { "DummyClass" }
+
+      subject { instance_spy(the_class) }
+
+      it_behaves_like "a verifying spy with a foo method"
+
+      it "takes a class name string and a hash of method names and return values" do
+        expect(instance_spy(the_class, :foo => :bar).foo).to eq(:bar)
+      end
+    end
+  end
+
+  describe "object_spy" do
+    let(:the_class) do
+      Class.new do
+        def foo
+          3
+        end
+      end
+    end
+
+    let(:the_instance) { the_class.new }
+
+    subject { object_spy(the_instance) }
+
+    it_behaves_like "a verifying spy with a foo method"
+
+    it "takes an instance and a hash of method names and return values" do
+      expect(object_spy(the_instance, :foo => :bar).foo).to eq(:bar)
+    end
+  end
+
+  describe "class_spy" do
+    let(:the_class) do
+      Class.new do
+        def self.foo
+          3
+        end
+      end
+    end
+
+    subject { class_spy(the_class) }
+
+    it_behaves_like "a verifying spy with a foo method"
+
+    it "takes a class and a hash of method names and return values" do
+      expect(class_spy(the_class, :foo => :bar).foo).to eq(:bar)
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks/stash_spec.rb

@@ -0,0 +1,43 @@
+module RSpec
+  module Mocks
+    RSpec.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
+        expect(klass).to receive(:foo).with(:fizbaz).and_return(:wowwow)
+        expect(klass).to receive(:foo).with(:bazbar).and_return(:okay)
+
+        klass.foo(:fizbaz)
+        klass.foo(:bazbar)
+        verify klass
+
+        reset klass
+        expect(klass.foo(:yeah)).to equal(:original_value)
+      end
+    end
+
+    RSpec.describe "when a class method is aliased on a subclass and the method is mocked" do
+      it "restores the original aliased public method" do
+        klass = Class.new do
+          class << self
+            alias alternate_new new
+          end
+        end
+
+        expect(klass).to receive(:alternate_new)
+        expect(klass.alternate_new).to be_nil
+
+        verify klass
+
+        reset klass
+        expect(klass.alternate_new).to be_an_instance_of(klass)
+      end
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks/stub_chain_spec.rb

@@ -0,0 +1,166 @@
+module RSpec
+  module Mocks
+    RSpec.describe "A chained method stub" do
+      let(:object) { Object.new }
+
+      it 'does not get confused by symbol vs string usage for the messages' do
+        allow(object).to receive_message_chain(:foo, :bar => 1)
+        allow(object).to receive_message_chain("foo", :bazz => 2)
+
+        expect(object.foo.bar).to eq(1)
+        expect(object.foo.bazz).to eq(2)
+      end
+
+      context "with one method in chain" do
+        context "using and_return" do
+          it "returns expected value from chaining only one method call" do
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_chain(:msg1 => :return_value)
+            expect(object.msg1).to equal(:return_value)
+          end
+        end
+      end
+
+      context "with two methods in chain" do
+        it "accepts any number of arguments to the stubbed messages in the chain" do
+          allow(object).to receive_message_chain(:msg1, :msg2).and_return(:return_value)
+
+          expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
+        end
+
+        context "using and_return" do
+          it "returns expected value from chaining two method calls" do
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+            allow(object).to receive_message_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
+        allow(object).to receive_message_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
+              allow(object).to receive_message_chain(:msg1, :msg2, :msg3).and_return(:first)
+              allow(object).to receive_message_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
+              allow(object).to receive_message_chain(:msg1, :msg2, :msg3).and_return(:first)
+              allow(object).to receive_message_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
+              allow(object).to receive_message_chain(:msg1, :msg2, :msg3 => :first)
+              allow(object).to receive_message_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
+              allow(object).to receive_message_chain(:msg1, :msg2, :msg3 => :first)
+              allow(object).to receive_message_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
+        allow(object).to receive_message_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
+        allow(object).to receive_message_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        allow(object).to receive_message_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
+        allow(object).to receive_message_chain(:msg1, :select, :msg3 => 'answer')
+        expect(object.msg1.select.msg3).to eq 'answer'
+      end
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks/stub_implementation_spec.rb

@@ -0,0 +1,98 @@
+module RSpec
+  module Mocks
+    RSpec.describe "stub implementation" do
+      describe "with no args" do
+        it "execs the block when called" do
+          obj = double()
+          allow(obj).to receive(: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 = double()
+          allow(obj).to receive(: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 = double()
+          allow(obj).to receive(:foo) {|*given| given.first}
+          expect(obj.foo(:bar)).to eq :bar
+        end
+      end
+    end
+
+    RSpec.describe "unstubbing with `and_call_original`" do
+      it "replaces the stubbed method with the original method" do
+        obj = Object.new
+        def obj.foo; :original; end
+        allow(obj).to receive(:foo)
+        allow(obj).to receive(:foo).and_call_original
+        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
+        allow(obj).to receive(:foo).with(1)
+        allow(obj).to receive(:foo).with(2)
+        allow(obj).to receive(:foo).and_call_original
+        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
+        expect(obj).to receive(:foo).with(3).and_return(:three)
+        allow(obj).to receive(:foo).with(1)
+        allow(obj).to receive(:foo).with(2)
+        allow(obj).to receive(:foo).and_call_original
+        expect(obj.foo(3)).to eq :three
+      end
+
+      shared_examples_for "stubbing `new` on class objects" do
+        it "restores the correct implementations when stubbed and unstubbed on a parent and child class" do
+          parent = stub_const("Parent", Class.new)
+          child  = stub_const("Child", Class.new(parent))
+
+          allow(parent).to receive(:new)
+          allow(child).to receive(:new)
+          allow(parent).to receive(:new).and_call_original
+          allow(child).to receive(:new).and_call_original
+
+          expect(parent.new).to be_an_instance_of parent
+          expect(child.new).to be_an_instance_of child
+        end
+
+        it "restores the correct implementations when stubbed and unstubbed on a grandparent and grandchild class" do
+          grandparent = stub_const("GrandParent", Class.new)
+          parent      = stub_const("Parent", Class.new(grandparent))
+          child       = stub_const("Child", Class.new(parent))
+
+          allow(grandparent).to receive(:new)
+          allow(child).to receive(:new)
+          allow(grandparent).to receive(:new).and_call_original
+          allow(child).to receive(:new).and_call_original
+
+          expect(grandparent.new).to be_an_instance_of grandparent
+          expect(child.new).to be_an_instance_of child
+        end
+      end
+
+      context "when partial doubles are not verified" do
+        before { expect(RSpec::Mocks.configuration.verify_partial_doubles?).to be false }
+        include_examples "stubbing `new` on class objects"
+      end
+
+      context "when partial doubles are verified" do
+        include_context "with isolated configuration"
+        before { RSpec::Mocks.configuration.verify_partial_doubles = true }
+        include_examples "stubbing `new` on class objects"
+      end
+    end
+  end
+end