dxruby_rp5 0.0.1

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

@@ -0,0 +1,353 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "A method stub" do
+      before(:each) do
+        @class = Class.new do
+          class << self
+            def existing_class_method
+              existing_private_class_method
+            end
+
+            private
+            def existing_private_class_method
+              :original_value
+            end
+          end
+
+          def existing_instance_method
+            existing_private_instance_method
+          end
+
+          private
+          def existing_private_instance_method
+            :original_value
+          end
+        end
+        @instance = @class.new
+        @stub = Object.new
+      end
+
+      describe "using stub" do
+        it "returns declared value when message is received" do
+          @instance.stub(:msg).and_return(:return_value)
+          expect(@instance.msg).to equal(:return_value)
+          verify @instance
+        end
+      end
+
+      describe "using stub!" do
+        before do
+          allow(RSpec).to receive(:deprecate)
+        end
+
+        it "warns of deprecation" do
+          expect(RSpec).to receive(:deprecate).with("stub!", :replacement => "stub")
+          @instance.stub!(:msg).and_return(:return_value)
+        end
+
+        it "returns the declared value when the message is received" do
+          @instance.stub!(:msg).and_return(:return_value)
+          expect(@instance.msg).to equal(:return_value)
+          verify @instance
+        end
+
+        it "can be used to stub the example context itself (since `stub` returns a test dobule instead)" do
+          stub!(:foo).and_return(5)
+          expect(foo).to eq(5)
+        end
+      end
+
+      describe 'using unstub' do
+        it 'removes the message stub' do
+          @instance.stub(:msg)
+          @instance.unstub(:msg)
+          expect { @instance.msg }.to raise_error NoMethodError
+        end
+      end
+
+      describe 'using unstub!' do
+        it 'removes the message stub but warns about deprecation' do
+          @instance.stub(:msg)
+          RSpec.should_receive(:deprecate).with("unstub!", :replacement => "unstub")
+          @instance.unstub!(:msg)
+          expect { @instance.msg }.to raise_error NoMethodError
+        end
+      end
+
+      it "instructs an instance to respond_to the message" do
+        @instance.stub(:msg)
+        expect(@instance).to respond_to(:msg)
+      end
+
+      it "instructs a class object to respond_to the message" do
+        @class.stub(:msg)
+        expect(@class).to respond_to(:msg)
+      end
+
+      it "ignores when expected message is received with no args" do
+        @instance.stub(:msg)
+        @instance.msg
+        expect do
+          verify @instance
+        end.not_to raise_error
+      end
+
+      it "ignores when message is received with args" do
+        @instance.stub(:msg)
+        @instance.msg(:an_arg)
+        expect do
+          verify @instance
+        end.not_to raise_error
+      end
+
+      it "ignores when expected message is not received" do
+        @instance.stub(:msg)
+        expect do
+          verify @instance
+        end.not_to raise_error
+      end
+
+      it "handles multiple stubbed methods" do
+        @instance.stub(:msg1 => 1, :msg2 => 2)
+        expect(@instance.msg1).to eq(1)
+        expect(@instance.msg2).to eq(2)
+      end
+
+      describe "#rspec_reset" do
+        it "removes stubbed methods that didn't exist" do
+          @instance.stub(:non_existent_method)
+          reset @instance
+          expect(@instance).not_to respond_to(:non_existent_method)
+        end
+
+        it "restores existing instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_instance_method) { :stub_value }
+          reset @instance
+          expect(@instance.existing_instance_method).to eq(:original_value)
+        end
+
+        it "restores existing private instance methods" do
+          # See bug reports 8302 adn 7805
+          @instance.stub(:existing_private_instance_method) { :stub_value }
+          reset @instance
+          expect(@instance.send(:existing_private_instance_method)).to eq(:original_value)
+        end
+
+        it "restores existing class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_class_method) { :stub_value }
+          reset @class
+          expect(@class.existing_class_method).to eq(:original_value)
+        end
+
+        it "restores existing private class methods" do
+          # See bug reports 8302 adn 7805
+          @class.stub(:existing_private_class_method) { :stub_value }
+          reset @class
+          expect(@class.send(:existing_private_class_method)).to eq(:original_value)
+        end
+
+        it "does not remove existing methods that have been stubbed twice" do
+          @instance.stub(:existing_instance_method)
+          @instance.stub(:existing_instance_method)
+
+          reset @instance
+
+          expect(@instance.existing_instance_method).to eq(:original_value)
+        end
+
+        it "correctly restores the visibility of methods whose visibility has been tweaked on the singleton class" do
+          # hello is a private method when mixed in, but public on the module
+          # itself
+          mod = Module.new {
+            extend self
+            def hello; :hello; end
+
+            private :hello
+            class << self; public :hello; end;
+          }
+
+          expect(mod.hello).to eq(:hello)
+
+          mod.stub(:hello) { :stub }
+          reset mod
+
+          expect(mod.hello).to eq(:hello)
+        end
+
+        if RUBY_VERSION >= '2.0.0'
+          context "with a prepended module (ruby 2.0.0+)" do
+            before do
+              mod = Module.new do
+                def existing_instance_method
+                  "#{super}_prepended".to_sym
+                end
+              end
+
+              @prepended_class = Class.new(@class) do
+                prepend mod
+
+                def non_prepended_method
+                  :not_prepended
+                end
+              end
+              @prepended_instance = @prepended_class.new
+            end
+
+            it "restores prepended instance methods" do
+              allow(@prepended_instance).to receive(:existing_instance_method) { :stubbed }
+              expect(@prepended_instance.existing_instance_method).to eq :stubbed
+
+              reset @prepended_instance
+              expect(@prepended_instance.existing_instance_method).to eq :original_value_prepended
+            end
+
+            it "restores non-prepended instance methods" do
+              allow(@prepended_instance).to receive(:non_prepended_method) { :stubbed }
+              expect(@prepended_instance.non_prepended_method).to eq :stubbed
+
+              reset @prepended_instance
+              expect(@prepended_instance.non_prepended_method).to eq :not_prepended
+            end
+          end
+        end
+      end
+
+      it "returns values in order to consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
+      end
+
+      it "keeps returning last value in consecutive calls" do
+        @instance.stub(:msg).and_return("1",2,:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
+      end
+
+      it "yields a specified object" do
+        @instance.stub(:method_that_yields).and_yield(:yielded_obj)
+        current_value = :value_before
+        @instance.method_that_yields {|val| current_value = val}
+        expect(current_value).to eq :yielded_obj
+        verify @instance
+      end
+
+      it "yields multiple times with multiple calls to and_yield" do
+        @instance.stub(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @instance.method_that_yields_multiple_times {|val| current_value << val}
+        expect(current_value).to eq [:yielded_value, :another_value]
+        verify @instance
+      end
+
+      it "yields a specified object and return another specified object" do
+        yielded_obj = double("my mock")
+        yielded_obj.should_receive(:foo).with(:bar)
+        @instance.stub(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        expect(@instance.method_that_yields_and_returns { |o| o.foo :bar }).to eq :baz
+      end
+
+      it "throws when told to" do
+        @stub.stub(:something).and_throw(:up)
+        expect { @stub.something }.to throw_symbol(:up)
+      end
+
+      it "throws with argument when told to" do
+        @stub.stub(:something).and_throw(:up, 'high')
+        expect { @stub.something }.to throw_symbol(:up, 'high')
+      end
+
+      it "overrides a pre-existing method" do
+        @stub.stub(:existing_instance_method).and_return(:updated_stub_value)
+        expect(@stub.existing_instance_method).to eq :updated_stub_value
+      end
+
+      it "overrides a pre-existing stub" do
+        @stub.stub(:foo) { 'bar' }
+        @stub.stub(:foo) { 'baz' }
+        expect(@stub.foo).to eq 'baz'
+      end
+
+      it "allows a stub and an expectation" do
+        @stub.stub(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "calculates return value by executing block passed to #and_return" do
+        @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        expect(@stub.something("a","b","c")).to eq "cba"
+        verify @stub
+      end
+    end
+
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub(:foo).with("bar")
+      end
+
+      it "does not complain if not called" do
+      end
+
+      it "does not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "complains if called with no arg" do
+        expect {
+          @stub.foo
+        }.to raise_error(/received :foo with unexpected arguments/)
+      end
+
+      it "complains if called with other arg", :github_issue => [123,147] do
+        expect {
+          @stub.foo("other")
+        }.to raise_error(/received :foo with unexpected arguments.*Please stub a default value/m)
+      end
+
+      it "does not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "complains if also mocked w/ different args AND called w/ a 3rd set of args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+        expect {
+          @stub.foo("other")
+        }.to raise_error
+      end
+
+      it "supports options" do
+        @stub.stub(:foo, :expected_from => "bar")
+      end
+
+      it 'uses the correct stubbed response when responding to a mock expectation' do
+        @stub.stub(:bar) { 15 }
+        @stub.stub(:bar).with(:eighteen) { 18 }
+        @stub.stub(:bar).with(:thirteen) { 13 }
+
+        @stub.should_receive(:bar).exactly(4).times
+
+        expect(@stub.bar(:blah)).to eq(15)
+        expect(@stub.bar(:thirteen)).to eq(13)
+        expect(@stub.bar(:eighteen)).to eq(18)
+        expect(@stub.bar).to eq(15)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe "expection set on previously stubbed method" do
+  it "fails if message is not received after expectation is set" do
+    double = double(:msg => nil)
+    double.msg
+    double.should_receive(:msg)
+    expect { verify double }.to raise_error(RSpec::Mocks::MockExpectationError)
+  end
+
+  it "outputs arguments of similar calls" do
+    double = double('double', :foo => true)
+    double.should_receive(:foo).with('first')
+    double.foo('second')
+    double.foo('third')
+    expect {
+      verify double
+    }.to raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
+    reset double
+  end
+
+  context "with argument constraint on stub" do
+    it "matches any args if no arg constraint set on expectation" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).and_return("expectation")
+      double.foo
+      verify double
+    end
+
+    it "matches specific args set on expectation" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(4)
+      verify double
+    end
+
+    it "fails if expectation's arg constraint is not met" do
+      double = double("mock")
+      double.stub(:foo).with(3).and_return("stub")
+      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
+      double.foo(3)
+      expect { verify double }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
+    end
+
+    it 'distinguishes between individual values and arrays properly' do
+      dbl = double
+      dbl.stub(:foo).with('a', ['b'])
+
+      expect {
+        dbl.foo(['a'], 'b')
+      }.to raise_error { |e|
+        expect(e.message).to include('expected: ("a", ["b"])', 'got: (["a"], "b")')
+      }
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+module RSpec
+  module Mocks
+
+    describe ".allow_message" do
+      let(:subject) { Object.new }
+
+      it "sets up basic message allowance" do
+        expect {
+          ::RSpec::Mocks.allow_message(subject, :basic)
+        }.to change {
+          subject.respond_to?(:basic)
+        }.to(true)
+
+        expect(subject.basic).to eq(nil)
+      end
+
+      it "sets up message allowance with params and return value" do
+        expect {
+          ::RSpec::Mocks.allow_message(subject, :x).with(:in).and_return(:out)
+        }.to change {
+          subject.respond_to?(:x)
+        }.to(true)
+
+        expect(subject.x(:in)).to eq(:out)
+      end
+
+      it "supports block implementations" do
+        ::RSpec::Mocks.allow_message(subject, :message) { :value }
+        expect(subject.message).to eq(:value)
+      end
+
+      it "does not set an expectation that the message will be received" do
+        ::RSpec::Mocks.allow_message(subject, :message)
+        expect { verify subject }.not_to raise_error
+      end
+    end
+
+    describe ".expect_message" do
+      let(:subject) { Object.new }
+
+      it "sets up basic message expectation, verifies as uncalled" do
+        expect {
+          ::RSpec::Mocks.expect_message(subject, :basic)
+        }.to change {
+          subject.respond_to?(:basic)
+        }.to(true)
+
+        expect { verify subject }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails if never is specified and the message is called" do
+        expect {
+          ::RSpec::Mocks.expect_message(subject, :foo).never
+          subject.foo
+        }.to raise_error(/expected.*0 times/)
+      end
+
+      it "sets up basic message expectation, verifies as called" do
+        ::RSpec::Mocks.expect_message(subject, :basic)
+        subject.basic
+        verify subject
+      end
+
+      it "sets up message expectation with params and return value" do
+        ::RSpec::Mocks.expect_message(subject, :msg).with(:in).and_return(:out)
+        expect(subject.msg(:in)).to eq(:out)
+        verify subject
+      end
+
+      it "accepts a block implementation for the expected message" do
+        ::RSpec::Mocks.expect_message(subject, :msg) { :value }
+        expect(subject.msg).to eq(:value)
+        verify subject
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe TestDouble do
+      before(:all) do
+        Module.class_eval do
+          private
+          def use; end
+        end
+      end
+
+      after(:all) do
+        Module.class_eval do
+          undef use
+        end
+      end
+
+      it 'can be extended onto a module to make it a pure test double that can mock private methods' do
+        double = Module.new
+        double.stub(:use)
+        expect { double.use }.to raise_error(/private method `use' called/)
+
+        double = Module.new { TestDouble.extend_onto(self) }
+        double.should_receive(:use).and_return(:ok)
+        expect(double.use).to be(:ok)
+      end
+
+      it 'sets the test double name when a name is passed' do
+        double = Module.new { TestDouble.extend_onto(self, "MyDouble") }
+        expect { double.foo }.to raise_error(/Mock "MyDouble" received/)
+      end
+
+      [[:should, :expect], [:expect], [:should]].each do |syntax|
+        context "with syntax #{syntax.inspect}" do
+          include_context "with syntax", syntax
+          it 'stubs the methods passed in the stubs hash' do
+            double = Module.new do
+              TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
+            end
+
+            expect(double.a).to eq(5)
+            expect(double.b).to eq(10)
+          end
+        end
+      end
+
+      it 'indicates what type of test double it is in error messages' do
+        double = Module.new do
+          TestDouble.extend_onto(self, "A", :__declared_as => "ModuleMock")
+        end
+        expect { double.foo }.to raise_error(/ModuleMock "A"/)
+      end
+
+      it 'is declared as a mock by default' do
+        double = Module.new { TestDouble.extend_onto(self) }
+        expect { double.foo }.to raise_error(/Mock received/)
+      end
+
+      it 'warns of deprecation of :null_object => true' do
+        RSpec.should_receive :deprecate
+        double = Class.new { TestDouble.extend_onto self, 'name', :null_object => true }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe "a double receiving to_ary" do
+  shared_examples "to_ary" do
+    it "can be overridden with a stub" do
+      obj.stub(:to_ary) { :non_nil_value }
+      expect(obj.to_ary).to be(:non_nil_value)
+    end
+
+    it "responds when overriden" do
+      obj.stub(:to_ary) { :non_nil_value }
+      expect(obj).to respond_to(:to_ary)
+    end
+
+    it "supports Array#flatten" do
+      obj = double('foo')
+      expect([obj].flatten).to eq([obj])
+    end
+  end
+
+  context "double as_null_object" do
+    let(:obj) { double('obj').as_null_object }
+    include_examples "to_ary"
+
+    it "does respond to to_ary" do
+      expect(obj).to respond_to(:to_ary)
+    end
+
+    it "does respond to to_a" do
+      expect(obj).to respond_to(:to_a)
+    end
+
+    it "returns nil" do
+      expect(obj.to_ary).to eq nil
+    end
+  end
+
+  context "double without as_null_object" do
+    let(:obj) { double('obj') }
+    include_examples "to_ary"
+
+    it "doesn't respond to to_ary" do
+      expect(obj).not_to respond_to(:to_ary)
+    end
+
+    it "doesn't respond to to_a", :if => ( RUBY_VERSION.to_f > 1.8 ) do
+      expect(obj).not_to respond_to(:to_a)
+    end
+
+    it "raises " do
+      expect { obj.to_ary }.to raise_error(NoMethodError)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "#twice" do
+      before(:each) do
+        @double = double("test double")
+      end
+
+      it "passes when called twice" do
+        @double.should_receive(:do_something).twice
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when called twice with specified args" do
+        @double.should_receive(:do_something).twice.with("1", 1)
+        @double.do_something("1", 1)
+        @double.do_something("1", 1)
+        verify @double
+      end
+
+      it "passes when called twice with unspecified args" do
+        @double.should_receive(:do_something).twice
+        @double.do_something("1")
+        @double.do_something(1)
+        verify @double
+      end
+
+      it "fails fast when call count is higher than expected" do
+        @double.should_receive(:do_something).twice
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when call count is lower than expected" do
+        @double.should_receive(:do_something).twice
+        @double.do_something
+        expect {
+          verify @double
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when called wrong args on the first call" do
+        @double.should_receive(:do_something).twice.with("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+
+      it "fails when called with wrong args on the second call" do
+        @double.should_receive(:do_something).twice.with("1", 1)
+        @double.do_something("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+    end
+  end
+end