opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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