dxruby_rp5 0.0.1

data/spec/vendor/rspec-mocks-2.14.4/spec/rspec/mocks/matchers/receive_spec.rb

@@ -0,0 +1,336 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Matchers::Receive do
+      include_context "with syntax", :expect
+
+      def verify_all
+        ::RSpec::Mocks.space.verify_all
+      end
+
+      shared_examples_for "a receive matcher" do |*options|
+        it 'allows the caller to configure how the subject responds' do
+          wrapped.to receive(:foo).and_return(5)
+          expect(receiver.foo).to eq(5)
+        end
+
+        it 'allows the caller to constrain the received arguments' do
+          wrapped.to receive(:foo).with(:a)
+          receiver.foo(:a)
+
+          expect {
+            receiver.foo(:b)
+          }.to raise_error(/received :foo with unexpected arguments/)
+        end
+
+        it 'allows a `do...end` block implementation to be provided' do
+          wrapped.to receive(:foo) do
+            4
+          end
+
+          expect(receiver.foo).to eq(4)
+        end
+
+        it 'allows chaining off a `do...end` block implementation to be provided' do
+          wrapped.to receive(:foo) do
+            4
+          end.and_return(6)
+
+          expect(receiver.foo).to eq(6)
+        end
+
+        it 'allows a `{ ... }` block implementation to be provided' do
+          wrapped.to receive(:foo) { 5 }
+          expect(receiver.foo).to eq(5)
+        end
+
+        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
+           'since that form actually binds to `receive`' do
+          wrapped.to receive(:foo) { :curly } do
+            :do_end
+          end
+
+          expect(receiver.foo).to eq(:curly)
+        end
+
+        it 'does not support other matchers', :unless => options.include?(:allow_other_matchers) do
+          expect {
+            wrapped.to eq(3)
+          }.to raise_error(UnsupportedMatcherError)
+        end
+      end
+
+      shared_examples_for "an expect syntax allowance" do |*options|
+        include_examples "a receive matcher", *options
+
+        it 'does not expect the message to be received' do
+          wrapped.to receive(:foo)
+          expect { verify_all }.not_to raise_error
+        end
+      end
+
+      shared_examples_for "an expect syntax negative allowance" do
+        it 'is disabled since this expression is confusing' do
+          expect {
+            wrapped.not_to receive(:foo)
+          }.to raise_error(/not_to receive` is not supported/)
+
+          expect {
+            wrapped.to_not receive(:foo)
+          }.to raise_error(/to_not receive` is not supported/)
+        end
+      end
+
+      shared_examples_for "an expect syntax expectation" do |*options|
+        include_examples "a receive matcher", *options
+
+        it 'sets up a message expectation that passes if the message is received' do
+          wrapped.to receive(:foo)
+          receiver.foo
+          verify_all
+        end
+
+        it 'sets up a message expectation that fails if the message is not received' do
+          wrapped.to receive(:foo)
+
+          expect {
+            verify_all
+          }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it "reports the line number of expectation of unreceived message", :pending => options.include?(:does_not_report_line_num) do
+          expected_error_line = __LINE__; wrapped.to receive(:foo)
+
+          expect {
+            verify_all
+          }.to raise_error { |e|
+            expect(e.backtrace.first).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
+          }
+        end
+      end
+
+      shared_examples_for "an expect syntax negative expectation" do
+        it 'sets up a negaive message expectation that passes if the message is not received' do
+          wrapped.not_to receive(:foo)
+          verify_all
+        end
+
+        it 'sets up a negative message expectation that fails if the message is received' do
+          wrapped.not_to receive(:foo)
+
+          expect {
+            receiver.foo
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'supports `to_not` as an alias for `not_to`' do
+          wrapped.to_not receive(:foo)
+
+          expect {
+            receiver.foo
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'allows the caller to constrain the received arguments' do
+          wrapped.not_to receive(:foo).with(:a)
+          def receiver.method_missing(*a); end # a poor man's stub...
+
+          expect {
+            receiver.foo(:b)
+          }.not_to raise_error
+
+          expect {
+            receiver.foo(:a)
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'prevents confusing double-negative expressions involving `never`' do
+          expect {
+            wrapped.not_to receive(:foo).never
+          }.to raise_error(/trying to negate it again/)
+
+          expect {
+            wrapped.to_not receive(:foo).never
+          }.to raise_error(/trying to negate it again/)
+        end
+      end
+
+      describe "allow(...).to receive" do
+        include_examples "an expect syntax allowance" do
+          let(:receiver) { double }
+          let(:wrapped)  { allow(receiver) }
+        end
+      end
+
+      describe "allow(...).not_to receive" do
+        include_examples "an expect syntax negative allowance" do
+          let(:wrapped) { allow(double) }
+        end
+      end
+
+      describe "allow_any_instance_of(...).to receive" do
+        include_examples "an expect syntax allowance" do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { allow_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      describe "allow_any_instance_of(...).not_to receive" do
+        include_examples "an expect syntax negative allowance" do
+          let(:wrapped) { allow_any_instance_of(Class.new) }
+        end
+      end
+
+      describe "expect(...).to receive" do
+        include_examples "an expect syntax expectation", :allow_other_matchers do
+          let(:receiver) { double }
+          let(:wrapped)  { expect(receiver) }
+        end
+      end
+
+      describe "expect_any_instance_of(...).to receive" do
+        include_examples "an expect syntax expectation", :does_not_report_line_num do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { expect_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      describe "expect(...).not_to receive" do
+        include_examples "an expect syntax negative expectation" do
+          let(:receiver) { double }
+          let(:wrapped)  { expect(receiver) }
+        end
+      end
+
+      describe "expect_any_instance_of(...).not_to receive" do
+        include_examples "an expect syntax negative expectation" do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { expect_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      shared_examples "using rspec-mocks in another test framework" do
+        it 'can use the `expect` syntax' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to receive(:foo).and_return(3)
+          end
+
+          expect(dbl.foo).to eq(3)
+        end
+
+        it 'expects the method to be called when `expect` is used' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to receive(:foo)
+          end
+
+          expect { verify dbl }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it 'supports `expect(...).not_to receive`' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).not_to receive(:foo)
+          end
+
+          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it 'supports `expect(...).to_not receive`' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to_not receive(:foo)
+          end
+
+          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+      end
+
+      context "when used in a test framework without rspec-expectations" do
+        let(:framework) do
+          Class.new do
+            include RSpec::Mocks::ExampleMethods
+
+            def eq(value)
+              double("MyMatcher")
+            end
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'cannot use `expect` with another matcher' do
+          expect {
+            framework.new.instance_eval do
+              expect(3).to eq(3)
+            end
+          }.to raise_error(/only the `receive` matcher is supported/)
+        end
+
+        it 'can toggle the available syntax' do
+          expect(framework.new).to respond_to(:expect)
+          RSpec::Mocks.configuration.syntax = :should
+          expect(framework.new).not_to respond_to(:expect)
+          RSpec::Mocks.configuration.syntax = :expect
+          expect(framework.new).to respond_to(:expect)
+        end
+
+        after { RSpec::Mocks.configuration.syntax = :expect }
+      end
+
+      context "when rspec-expectations is included in the test framework first" do
+        before do
+          # the examples here assume `expect` is define in RSpec::Matchers...
+          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
+        end
+
+        let(:framework) do
+          Class.new do
+            include RSpec::Matchers
+            include RSpec::Mocks::ExampleMethods
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'can use `expect` with any matcher' do
+          framework.new.instance_eval do
+            expect(3).to eq(3)
+          end
+        end
+      end
+
+      context "when rspec-expectations is included in the test framework last" do
+        before do
+          # the examples here assume `expect` is define in RSpec::Matchers...
+          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
+        end
+
+        let(:framework) do
+          Class.new do
+            include RSpec::Mocks::ExampleMethods
+            include RSpec::Matchers
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'can use `expect` with any matcher' do
+          framework.new.instance_eval do
+            expect(3).to eq(3)
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/vendor/rspec-mocks-2.14.4/spec/rspec/mocks/methods_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "Methods added to every object" do
+      include_context "with syntax", :expect
+
+      def added_methods
+        host = Class.new
+        orig_instance_methods = host.instance_methods
+        Syntax.enable_should(host)
+        (host.instance_methods - orig_instance_methods).map(&:to_sym)
+      end
+
+      it 'limits the number of methods that get added to all objects' do
+        # If really necessary, you can add to this list, but long term,
+        # we are hoping to cut down on the number of methods added to all objects
+        expect(added_methods).to match_array([
+          :as_null_object, :null_object?,
+          :received_message?, :should_not_receive, :should_receive,
+          :stub, :stub!, :stub_chain, :unstub, :unstub!
+        ])
+      end
+    end
+  end
+end
+

data/spec/vendor/rspec-mocks-2.14.4/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  { reset @double }
+
+      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")
+        reset a
+        reset b
+      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
+        verify @double
+      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/spec/vendor/rspec-mocks-2.14.4/spec/rspec/mocks/mock_space_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+module RSpec
+  module Mocks
+    describe Space do
+      let(:space) { RSpec::Mocks::Space.new }
+      let(:dbl_1) { Object.new }
+      let(:dbl_2) { Object.new }
+
+      before do
+        space.ensure_registered(dbl_1)
+        space.ensure_registered(dbl_2)
+      end
+
+      it "verifies all mocks within" do
+        verifies = []
+
+        space.proxy_for(dbl_1).stub(:verify) { verifies << :dbl_1 }
+        space.proxy_for(dbl_2).stub(: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 "resets all mocks within" do
+        resets = []
+
+        space.proxy_for(dbl_1).stub(:reset) { resets << :dbl_1 }
+        space.proxy_for(dbl_2).stub(:reset) { resets << :dbl_2 }
+
+        space.reset_all
+
+        expect(resets).to match_array([:dbl_1, :dbl_2])
+      end
+
+      it "does not leak mock proxies between examples" do
+        expect {
+          space.reset_all
+        }.to change { space.proxies.size }.to(0)
+      end
+
+      it 'does not leak any instance recorders between examples' do
+        space.any_instance_recorder_for(Class.new)
+        expect {
+          space.reset_all
+        }.to change { space.any_instance_recorders.size }.to(0)
+      end
+
+      it "resets the ordering" do
+        space.expectation_ordering.register :some_expectation
+
+        expect {
+          space.reset_all
+        }.to change { space.expectation_ordering.empty? }.from(false).to(true)
+      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
+
+      it 'returns a consistent any_instance_recorder for a given class' do
+        klass_1, klass_2 = Class.new, Class.new
+
+        r1 = space.any_instance_recorder_for(klass_1)
+        r2 = space.any_instance_recorder_for(klass_1)
+        r3 = space.any_instance_recorder_for(klass_2)
+
+        expect(r1).to be(r2)
+        expect(r1).not_to be(r3)
+      end
+
+      it 'removes an any_instance_recorder when requested' do
+        klass = Class.new
+
+        space.any_instance_recorder_for(klass)
+
+        expect {
+          space.remove_any_instance_recorder_for(klass)
+        }.to change { space.any_instance_recorders.size }.by(-1)
+      end
+    end
+  end
+end
+