spy 0.1.0 → 0.2.1

data/spec/spy/double_spec.rb

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

data/spec/spy/failing_argument_matchers_spec.rb

@@ -1,94 +0,0 @@
-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
-        @double.rspec_reset
-      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
-    end
-  end
-end

data/spec/spy/options_hash_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "calling :should_receive with an options hash" do
-      it "reports the file and line submitted with :expected_from" do
-        begin
-          mock = RSpec::Mocks::Mock.new("a mock")
-          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
-          mock.rspec_verify
-        rescue Exception => e
-        ensure
-          expect(e.backtrace.to_s).to match /\/path\/to\/blah.ext:37/m
-        end
-      end
-
-      it "uses the message supplied with :message" do
-        expect {
-          m = RSpec::Mocks::Mock.new("a mock")
-          m.should_receive(:message, :message => "recebi nada")
-          m.rspec_verify
-        }.to raise_error("recebi nada")
-      end
-
-      it "uses the message supplied with :message after a similar stub" do
-        expect {
-          m = RSpec::Mocks::Mock.new("a mock")
-          Spy.on(m, :message)
-          m.should_receive(:message, :message => "from mock")
-          m.rspec_verify
-        }.to raise_error("from mock")
-      end
-    end
-  end
-end

data/spec/spy/precise_counts_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "PreciseCounts" do
-      before(:each) do
-        @double = double("test double")
-      end
-
-      it "fails when exactly n times method is called less than n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails fast when exactly n times method is called more than n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when exactly n times method is never called" do
-        @double.should_receive(:do_something).exactly(3).times
-        expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "passes if exactly n times method is called exactly n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.rspec_verify
-      end
-
-      it "returns the value given by a block when the exactly once method is called" do
-        @double.should_receive(:to_s).exactly(:once) { "testing" }
-        expect(@double.to_s).to eq "testing"
-        @double.rspec_verify
-      end
-
-      it "passes mutiple calls with different args" do
-        @double.should_receive(:do_something).once.with(1)
-        @double.should_receive(:do_something).once.with(2)
-        @double.do_something(1)
-        @double.do_something(2)
-        @double.rspec_verify
-      end
-
-      it "passes multiple calls with different args and counts" do
-        @double.should_receive(:do_something).twice.with(1)
-        @double.should_receive(:do_something).once.with(2)
-        @double.do_something(1)
-        @double.do_something(2)
-        @double.do_something(1)
-        @double.rspec_verify
-      end
-    end
-  end
-end

data/spec/spy/stubbed_message_expectations_spec.rb

@@ -1,47 +0,0 @@
-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 { double.rspec_verify }.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 {
-      double.rspec_verify
-    }.to raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
-    double.rspec_reset
-  end
-
-  context "with argument constraint on stub" do
-    it "matches any args if no arg constraint set on expectation" do
-      double = double("mock")
-      Spy.on(double, :foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).and_return("expectation")
-      double.foo
-      double.rspec_verify
-    end
-
-    it "matches specific args set on expectation" do
-      double = double("mock")
-      Spy.on(double, :foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(4)
-      double.rspec_verify
-    end
-
-    it "fails if expectation's arg constraint is not met" do
-      double = double("mock")
-      Spy.on(double, :foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(3)
-      expect { double.rspec_verify }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
-    end
-  end
-end

data/spec/spy/test_double_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-module Spy
-  describe Double 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
-      Spy.on(double, :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
-
-    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
-
-    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
-  end
-end