dxruby_rp5 0.0.1

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

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "Combining implementation instructions" do
+      it 'can combine and_yield and and_return' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return(3)
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(3)
+        }.to yield_with_args(5)
+      end
+
+      describe "combining and_yield, a block implementation and and_return" do
+        def verify_combined_implementation
+          dbl = double
+          (yield dbl).and_yield(5).and_return(3)
+
+          expect { |b|
+            expect(dbl.foo(:arg, &b)).to eq(3)
+          }.to yield_with_args(5)
+
+          expect(@block_called).to be_true
+        end
+
+        it 'works when passing a block to `stub`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `with`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo).with(:arg) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `exactly`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_least`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_most`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `any_number_of_times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).any_number_of_times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `once`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).once { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `twice`' do
+          the_double = nil
+
+          verify_combined_implementation do |dbl|
+            the_double = dbl
+            dbl.should_receive(:foo).twice { @block_called = true }
+          end
+
+          the_double.foo { |a| } # to ensure it is called twice
+        end
+
+        it 'works when passing a block to `ordered`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).ordered { @block_called = true }
+          end
+        end
+      end
+
+      it 'can combine and_yield and and_return with a block' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return { :return }
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(:return)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield and and_raise' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_raise' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'can combine and_yield and and_throw' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_throw' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'returns `nil` from all terminal actions to discourage further configuration' do
+        expect(double.stub(:foo).and_return(1)).to be_nil
+        expect(double.stub(:foo).and_raise("boom")).to be_nil
+        expect(double.stub(:foo).and_throw(:foo)).to be_nil
+      end
+
+      it 'allows the terminal action to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.and_return(1)
+        expect(dbl.foo).to eq(1)
+
+        stubbed_double.and_return(3)
+        expect(dbl.foo).to eq(3)
+
+        stubbed_double.and_raise("boom")
+        expect { dbl.foo }.to raise_error("boom")
+
+        stubbed_double.and_throw(:bar)
+        expect { dbl.foo }.to throw_symbol(:bar)
+      end
+
+      it 'allows the inner implementation block to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.with(:arg) { :with_block }
+        expect(dbl.foo(:arg)).to eq(:with_block)
+
+        stubbed_double.at_least(:once) { :at_least_block }
+        expect(dbl.foo(:arg)).to eq(:at_least_block)
+      end
+
+      it 'can combine and_call_original, with, and_return' do
+        obj = Struct.new(:value).new('original')
+        obj.stub(:value).and_call_original
+        obj.stub(:value).with(:arg).and_return('value')
+        expect(obj.value).to eq 'original'
+        expect(obj.value(:arg)).to eq 'value'
+      end
+
+      it 'raises an error if `and_call_original` is followed by any other instructions' do
+        dbl = [1, 2, 3]
+        stubbed = dbl.stub(:size)
+        stubbed.and_call_original
+
+        msg_fragment = /cannot be modified further/
+
+        expect { stubbed.and_yield }.to raise_error(msg_fragment)
+        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
+        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
+        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
+
+        expect { stubbed.once { } }.to raise_error(msg_fragment)
+
+        expect(dbl.size).to eq(3)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Configuration do
+      let(:config) { Configuration.new }
+      let(:mod_1)  { Module.new }
+      let(:mod_2)  { Module.new }
+
+      def instance_methods_of(mod)
+        mod_1.instance_methods.map(&:to_sym)
+      end
+
+      it 'adds stub and should_receive to the given modules' do
+        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
+
+        config.add_stub_and_should_receive_to(mod_1, mod_2)
+
+        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
+      end
+
+      shared_examples_for "configuring the syntax" do
+        def sandboxed
+          orig_syntax = RSpec::Mocks.configuration.syntax
+          yield
+        ensure
+          configure_syntax(orig_syntax)
+        end
+
+        around(:each) { |ex| sandboxed(&ex) }
+        let(:dbl) { double }
+        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
+        let(:should_class_methods) { [:any_instance] }
+        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
+
+        it 'defaults to enabling both the :should and :expect syntaxes' do
+          expect(dbl).to respond_to(*should_methods)
+          expect(self).to respond_to(*expect_methods)
+        end
+
+        context 'when configured to :expect' do
+          before { configure_syntax :expect }
+
+          it 'removes the should methods from every object' do
+            expect(dbl).not_to respond_to(*should_methods)
+          end
+
+          it 'removes `any_instance` from every class' do
+            expect(Class.new).not_to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :expect' do
+            expect(configured_syntax).to eq([:expect])
+          end
+
+          it 'is a no-op when configured a second time' do
+            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
+            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
+            configure_syntax :expect
+          end
+        end
+
+        context 'when configured to :should' do
+          before { configure_syntax :should }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'removes the expect methods from the example group context' do
+            expect(self).not_to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :should' do
+            expect(configured_syntax).to eq([:should])
+          end
+
+          it 'is a no-op when configured a second time' do
+            Syntax.default_should_syntax_host.should_not_receive(:method_added)
+            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
+            configure_syntax :should
+          end
+        end
+
+        context 'when configured to [:should, :expect]' do
+          before { configure_syntax [:should, :expect] }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that both syntaxes are enabled' do
+            expect(configured_syntax).to eq([:should, :expect])
+          end
+        end
+      end
+
+      describe "configuring rspec-mocks directly" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec::Mocks.configuration.syntax = syntax
+          end
+
+          def configured_syntax
+            RSpec::Mocks.configuration.syntax
+          end
+        end
+      end
+
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.syntax = syntax
+              end
+            end
+          end
+
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                return c.syntax
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "double" do
+  it "is an alias for stub and mock" do
+    expect(double()).to be_a(RSpec::Mocks::Mock)
+  end
+
+  it "uses 'Double' in failure messages" do
+    double = double('name')
+    expect {double.foo}.to raise_error(/Double "name" received/)
+  end
+
+  describe "deprecated aliases" do
+    it "warns if #stub is used" do
+      expect(RSpec).to receive(:deprecate).with("stub", :replacement => "double")
+      stub("TestDouble")
+    end
+
+    it "warns if #mock is used" do
+      expect(RSpec).to receive(:deprecate).with("mock", :replacement => "double")
+      mock("TestDouble")
+    end
+  end
+end

data/spec/vendor/rspec-mocks-2.14.4/spec/rspec/mocks/extensions/marshal_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Marshal, 'extensions' do
+  # An object that raises when code attempts to dup it.
+  #
+  # Because we manipulate the internals of RSpec::Mocks.space below, we need
+  # an object that simply blows up when #dup is called without using any
+  # partial mocking or stubbing from rspec-mocks itself.
+  class UndupableObject
+    def dup
+      raise NotImplementedError
+    end
+  end
+
+  describe '#dump' do
+    context 'when rspec-mocks has not been fully initialized' do
+      def without_space
+        stashed_space, RSpec::Mocks.space = RSpec::Mocks.space, nil
+        yield
+      ensure
+        RSpec::Mocks.space = stashed_space
+      end
+
+      it 'does not duplicate the object before serialization' do
+        obj = UndupableObject.new
+        without_space do
+          serialized = Marshal.dump(obj)
+          expect(Marshal.load(serialized)).to be_an(UndupableObject)
+        end
+      end
+    end
+
+    context 'when rspec-mocks has been fully initialized' do
+      it 'duplicates objects with stubbed or mocked implementations before serialization' do
+        obj = double(:foo => "bar")
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(obj.class)
+      end
+
+      it 'does not duplicate other objects before serialization' do
+        obj = UndupableObject.new
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(UndupableObject)
+      end
+
+      it 'does not duplicate nil before serialization' do
+        serialized = Marshal.dump(nil)
+        expect(Marshal.load(serialized)).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "failing MockArgumentMatchers" do
+      before(:each) do
+        @double = double("double")
+        @reporter = double("reporter").as_null_object
+      end
+
+      after(:each) do
+        reset @double
+      end
+
+      it "rejects non boolean" do
+        @double.should_receive(:random_call).with(boolean())
+        expect do
+          @double.random_call("false")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non numeric" do
+        @double.should_receive(:random_call).with(an_instance_of(Numeric))
+        expect do
+          @double.random_call("1")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects non string" do
+        @double.should_receive(:random_call).with(an_instance_of(String))
+        expect do
+          @double.random_call(123)
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "rejects goose when expecting a duck" do
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted string" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if regexp does not match submitted regexp" do
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails for a hash w/ wrong values" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call(:a => "b", :c => "e")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+
+      it "fails for a hash w/ wrong keys" do
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call("a" => "b", "c" => "d")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+
+      it "matches against a Matcher" do
+        expect do
+          @double.should_receive(:msg).with(equal(3))
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+      end
+
+      it "fails no_args with one arg" do
+        expect do
+          @double.should_receive(:msg).with(no_args)
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+      end
+
+      it "fails hash_including with missing key" do
+         expect do
+           @double.should_receive(:msg).with(hash_including(:a => 1))
+           @double.msg({})
+         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+      end
+
+      it "fails with block matchers" do
+        expect do
+          @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
+          @double.msg :no_msg_for_you
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+
+      it "fails with sensible message when args respond to #description" do
+        arg = Class.new do
+          def description
+          end
+
+          def inspect
+            "my_thing"
+          end
+        end.new
+
+        expect do
+          @double.should_receive(:msg).with(3)
+          @double.msg arg
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (3)\n       got: (my_thing)")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashExcludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
+        end
+
+        describe "passing" do
+          it "matches a hash without the specified key" do
+            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches a hash with the specified key, but different value" do
+            expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches a hash without the specified key, given as anything()" do
+            expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
+          end
+
+          it "matches an empty hash" do
+            expect(hash_not_including(:a)).to eq({})
+          end
+
+          it "matches a hash without any of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
+          end
+
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_not_including(:a => 1)).not_to eq 1
+          end
+
+          it "does not match a hash with a specified key" do
+            expect(hash_not_including(:b)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with the specified key/value pair" do
+            expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with the specified key" do
+            expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with one of the specified keys" do
+            expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with some of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
+          end
+
+          it "does not match a hash with one key/value pair included" do
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
+          end
+        end
+      end
+    end
+  end
+end