dxruby_rp5 0.0.1

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe "AnyNumberOfTimes" do
+  before(:each) do
+    @mock = RSpec::Mocks::Mock.new("test mock")
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
+    expect(@mock).to receive(:random_call).any_number_of_times
+  end
+
+  it "passes if any number of times method is called many times" do
+    @mock.should_receive(:random_call).any_number_of_times
+    (1..10).each do
+      @mock.random_call
+    end
+  end
+
+  it "passes if any number of times method is called once" do
+    @mock.should_receive(:random_call).any_number_of_times
+    @mock.random_call
+  end
+
+  it "passes if any number of times method is not called" do
+    @mock.should_receive(:random_call).any_number_of_times
+  end
+
+  it "returns the mocked value when called after a similar stub" do
+    @mock.stub(:message).and_return :stub_value
+    @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
+    expect(@mock.message).to eq :mock_value
+    expect(@mock.message).to eq :mock_value
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe ArgumentListMatcher do
+      let(:argument_expectation) { RSpec::Mocks::ArgumentListMatcher.new }
+      let(:obj) { double("matcher") }
+
+      it "considers an object that responds to #matches? and #failure_message_for_should to be a matcher" do
+        obj.stub(:matches?)
+        obj.stub(:failure_message_for_should)
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_true
+      end
+
+      it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
+        obj.stub(:matches?)
+        obj.stub(:failure_message)
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_true
+      end
+
+      it "does NOT consider an object that only responds to #matches? to be a matcher" do
+        obj.stub(:matches?)
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_false
+      end
+
+      it "does not consider a null object to be a matcher" do
+        obj.as_null_object
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "at_least" do
+      before(:each) { @double = double }
+
+      it "fails if method is never called" do
+        @double.should_receive(:do_something).at_least(4).times
+        expect {
+          verify @double
+        }.to raise_error(/expected: at least 4 times.*received: 0 times/m)
+      end
+
+      it "fails when called less than n times" do
+        @double.should_receive(:do_something).at_least(4).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        expect {
+          verify @double
+        }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
+      end
+
+      it "fails when at least once method is never called" do
+        @double.should_receive(:do_something).at_least(:once)
+        expect {
+          verify @double
+        }.to raise_error(/expected: at least 1 time.*received: 0 times/m)
+      end
+
+      it "fails when at least twice method is called once" do
+        @double.should_receive(:do_something).at_least(:twice)
+        @double.do_something
+        expect {
+          verify @double
+        }.to raise_error(/expected: at least 2 times.*received: 1 time/m)
+      end
+
+      it "fails when at least twice method is never called" do
+        @double.should_receive(:do_something).at_least(:twice)
+        expect {
+          verify @double
+        }.to raise_error(/expected: at least 2 times.*received: 0 times/m)
+      end
+
+      it "passes when at least n times method is called exactly n times" do
+        @double.should_receive(:do_something).at_least(4).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at least n times method is called n plus 1 times" do
+        @double.should_receive(:do_something).at_least(4).times
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at least once method is called once" do
+        @double.should_receive(:do_something).at_least(:once)
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at least once method is called twice" do
+        @double.should_receive(:do_something).at_least(:once)
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at least twice method is called three times" do
+        @double.should_receive(:do_something).at_least(:twice)
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at least twice method is called twice" do
+        @double.should_receive(:do_something).at_least(:twice)
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "returns the value given by a block when the at least once method is called" do
+        @double.should_receive(:to_s).at_least(:once) { "testing" }
+        expect(@double.to_s).to eq "testing"
+        verify @double
+      end
+
+      context "when sent with 0" do
+        before { RSpec.stub(:deprecate) }
+
+        it "outputs a deprecation warning" do
+          expect(RSpec).to receive(:deprecate).with("at_least\(0\) with should_receive", :replacement => "stub")
+          expect(@double).to receive(:do_something).at_least(0).times
+        end
+
+        it "passes with no return if called once" do
+          @double.should_receive(:do_something).at_least(0).times
+          @double.do_something
+        end
+
+        it "passes with return block if called once" do
+          @double.should_receive(:do_something).at_least(0).times { true }
+          @double.do_something
+        end
+
+        it "passes with and_return if called once" do
+          @double.should_receive(:do_something).at_least(0).times.and_return true
+          @double.do_something
+        end
+
+        it "passes with no return if never called" do
+          @double.should_receive(:do_something).at_least(0).times
+        end
+
+        it "passes with return block if never called" do
+          @double.should_receive(:do_something).at_least(0).times { true }
+        end
+
+        it "passes with and_return if never called" do
+          @double.should_receive(:do_something).at_least(0).times.and_return true
+        end
+      end
+
+      it "uses a stub value if no value set" do
+        @double.stub(:do_something => 'foo')
+        @double.should_receive(:do_something).at_least(:once)
+        expect(@double.do_something).to eq 'foo'
+        expect(@double.do_something).to eq 'foo'
+      end
+
+      it "prefers its own return value over a stub" do
+        @double.stub(:do_something => 'foo')
+        @double.should_receive(:do_something).at_least(:once).and_return('bar')
+        expect(@double.do_something).to eq 'bar'
+        expect(@double.do_something).to eq 'bar'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "at_most" do
+      before(:each) do
+        @double = double
+      end
+
+      it "passes when at_most(n) is called exactly n times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at_most(n) is called less than n times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at_most(n) is never called" do
+        @double.should_receive(:do_something).at_most(2).times
+        verify @double
+      end
+
+      it "passes when at_most(:once) is called once" do
+        @double.should_receive(:do_something).at_most(:once)
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at_most(:once) is never called" do
+        @double.should_receive(:do_something).at_most(:once)
+        verify @double
+      end
+
+      it "passes when at_most(:twice) is called once" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at_most(:twice) is called twice" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when at_most(:twice) is never called" do
+        @double.should_receive(:do_something).at_most(:twice)
+        verify @double
+      end
+
+      it "returns the value given by a block when at_most(:once) method is called" do
+        @double.should_receive(:to_s).at_most(:once) { "testing" }
+        expect(@double.to_s).to eq "testing"
+        verify @double
+      end
+
+      it "fails fast when at_most(n) times method is called n plus 1 times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
+      end
+
+      it "fails fast when at_most(:once) and is called twice" do
+        @double.should_receive(:do_something).at_most(:once)
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(/expected: at most 1 time.*received: 2 times/m)
+      end
+
+      it "fails fast when at_most(:twice) and is called three times" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe "a double declaration with a block handed to:" do
+  describe "should_receive" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.should_receive(:foo) { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+
+    it "works when a multi-return stub has already been set" do
+      obj = Object.new
+      return_value = Object.new
+      obj.stub(:foo).and_return(return_value, nil)
+      obj.should_receive(:foo) { return_value }
+      expect(obj.foo).to be(return_value)
+    end
+  end
+
+  describe "stub" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.stub(:foo) { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+
+    it "does not complain if a lambda block and mismatched arguments are passed" do
+      obj = Object.new
+      obj.stub(:foo, &lambda { 'bar' })
+      expect(obj.foo(1, 2)).to eq('bar')
+    end
+  end
+
+  describe "with" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.stub(:foo).with('baz') { 'bar' }
+      expect(obj.foo('baz')).to eq('bar')
+    end
+
+    it "does not complain if a lambda block and mismatched arguments are passed" do
+      obj = Object.new
+      obj.stub(:foo).with(1, 2, &lambda { 'bar' })
+      expect(obj.foo(1, 2)).to eq('bar')
+    end
+  end
+
+  %w[once twice ordered and_return].each do |method|
+    describe method do
+      it "returns the value of executing the block" do
+        obj = Object.new
+        obj.stub(:foo).send(method) { 'bar' }
+        expect(obj.foo).to eq('bar')
+      end
+
+      it "does not complain if a lambda block and mismatched arguments are passed" do
+        obj = Object.new
+        obj.stub(:foo).send(method, &lambda { 'bar' })
+        expect(obj.foo(1, 2)).to eq('bar')
+      end
+    end
+  end
+
+  describe 'any_number_of_times' do
+    before do
+      RSpec.stub(:deprecate)
+    end
+
+    it "warns about deprecation" do
+      expect(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
+      Object.new.stub(:foo).any_number_of_times { 'bar' }
+    end
+
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.stub(:foo).any_number_of_times { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+  end
+
+  describe "times" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.stub(:foo).at_least(1).times { 'bar' }
+      expect(obj.foo('baz')).to eq('bar')
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "An RSpec Mock" do
+  it "hides internals in its inspect representation" do
+    m = double('cup')
+    expect(m.inspect).to match(/#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/)
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "Double" do
+  let(:test_double) { double }
+
+  specify "when one example has an expectation inside the block passed to should_receive" do
+    test_double.should_receive(:msg) do |arg|
+      expect(arg).to be_true #this call exposes the problem
+    end
+    begin
+      test_double.msg(false)
+    rescue Exception
+    end
+  end
+
+  specify "then the next example should behave as expected instead of saying" do
+    test_double.should_receive(:foobar)
+    test_double.foobar
+    verify test_double
+    begin
+      test_double.foobar
+    rescue Exception => e
+      expect(e.message).to eq "Double received unexpected message :foobar with (no args)"
+    end
+  end
+end
+

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class LiarLiarPantsOnFire
+  def respond_to?(message, incl_private=false)
+    true
+  end
+
+  def self.respond_to?(message, incl_private=false)
+    true
+  end
+end
+
+describe 'should_receive' do
+  before(:each) do
+    @liar = LiarLiarPantsOnFire.new
+  end
+
+  it "works when object lies about responding to a method" do
+    @liar.should_receive(:something)
+    @liar.something
+  end
+
+  it 'works when class lies about responding to a method' do
+    LiarLiarPantsOnFire.should_receive(:something)
+    LiarLiarPantsOnFire.something
+  end
+
+  it 'cleans up after itself' do
+    expect((class << LiarLiarPantsOnFire; self; end).instance_methods).not_to include("something")
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module BugReport496
+  describe "a message expectation on a base class object" do
+    class BaseClass
+    end
+
+    class SubClass < BaseClass
+    end
+
+    it "is received" do
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module BugReport600
+  describe "stubbing a class method" do
+    class ExampleClass
+      def self.method_that_uses_define_method
+        define_method "defined_method" do |attributes|
+          load_address(address, attributes)
+        end
+      end
+    end
+
+    it "works" do
+      ExampleClass.should_receive(:define_method).with("defined_method")
+      ExampleClass.method_that_uses_define_method
+    end
+
+    it "restores the original method" do
+      ExampleClass.method_that_uses_define_method
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Bug7611
+  describe "A Partial Mock" do
+    class Foo; end
+    class Bar < Foo; end
+
+    it "respects subclasses" do
+      Foo.stub(:new).and_return(Object.new)
+    end
+
+    it "should" do
+      expect(Bar.new.class).to eq Bar
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "An object where respond_to? is true and does not have method" do
+  # When should_receive(message) is sent to any object, the Proxy sends
+  # respond_to?(message) to that object to see if the method should be proxied.
+  #
+  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
+  # to the object, the proxy is invoked and responds yes (if so set in the spec).
+  # When the object does NOT actually respond to `message`, an exception is thrown
+  # when trying to proxy it.
+  #
+  # The fix was to keep track of whether `respond_to?` had been proxied and, if
+  # so, call the munged copy of `respond_to?` on the object.
+
+  it "does not raise an exception for Object" do
+    obj = Object.new
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+  it "does not raise an exception for mock" do
+    obj = double("obj")
+    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
+    obj.should_receive(:foobar).and_return(:baz)
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
+  end
+
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe 'Calling a method that catches StandardError' do
+      class Foo
+        def self.foo
+          bar
+        rescue StandardError
+        end
+      end
+
+      it 'still reports mock failures' do
+        Foo.should_not_receive :bar
+        expect {
+          Foo.foo
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "stubbing a base class class method" do
+      before do
+        @base_class     = Class.new
+        @concrete_class = Class.new(@base_class)
+
+        @base_class.stub(:find).and_return "stubbed_value"
+      end
+
+      it "returns the value for the stub on the base class" do
+        expect(@base_class.find).to eq "stubbed_value"
+      end
+
+      it "returns the value for the descendent class" do
+        expect(@concrete_class.find).to eq "stubbed_value"
+      end
+    end
+  end
+end