bogus 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5692979cf19268250f0bd23067c79beca39210f9
-  data.tar.gz: eace904b3205850ab8a3359453d4fe1236e120fe
+SHA256:
+  metadata.gz: f19fb1ce0b29dead39cdc4fefdd2fb496abafbfc2fe1ce958f31a6dcf91cf708
+  data.tar.gz: 3694b31fbc3f9211de7e309d72042abd98e35fc5c63cb4fb32dce87484d7fde3
 SHA512:
-  metadata.gz: f8be32e8fbc29928cc5f517c10bf6602dee35910e0c2768d83ec0db7c8a62bdd993cc84482aec9d26dd4ecce2f096f80ac0c9bc8ed2c7f6092bf0e570c7fcf54
-  data.tar.gz: b12ed7d4b58170ff5f7180f559c054817ff7b84476808355d822b7d5270a34083d77f10996036d17d5a45f6da2da80b4e7e4de065e32ab65f244960b1fec43f5
+  metadata.gz: e324b7b0f9e4c1a8c5403de4d6ccd3a9a1e694a72d63a88af4c27819c59d3cd0c26e6ca22de87a304853b2c0189902a764efc543d6493c12a60a0ba262e5c737
+  data.tar.gz: d7489aa2eb177b1fd20409b808ad16f1b37183bfc226b56ce15ce3126472dc3e47a87a8c7724faf9daf910b789c96184c5925d86274b72314f9791a62d265c84

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
 rvm:
   - 1.9.3
-  - 2.0
-  - 2.1.1
-  - jruby-19mode
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - jruby
+  - rbx
 script: bundle exec rspec spec && bundle exec cucumber --tag ~@wip
+sudo: false

data/Gemfile

@@ -2,5 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in bogus.gemspec
 gemspec
-
-gem 'minitest', require: false

data/Guardfile

@@ -1,7 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec', all_after_pass: true, all_on_start: true do
+guard 'rspec', cmd: 'bundle exec rspec', all_after_pass: true, all_on_start: true do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }

data/bogus.gemspec

@@ -12,8 +12,6 @@ Gem::Specification.new do |s|
   s.summary     = %q{Create fakes to make your isolated unit tests reliable.}
   s.description = %q{Decreases the need to write integration tests by ensuring that the things you stub or mock actually exist.}
 
-  s.rubyforge_project = "bogus"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -32,11 +30,11 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'guard-ctags-bundler'
   s.add_development_dependency 'growl'
   s.add_development_dependency 'libnotify'
-  s.add_development_dependency 'rr'
   s.add_development_dependency 'relish'
   s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'wwtd'
 
-  s.add_development_dependency 'activerecord', '>= 3', '< 5'
+  s.add_development_dependency 'activerecord', '>= 3', '< 7'
   s.add_development_dependency 'activerecord-nulldb-adapter'
 
   s.add_development_dependency 'minitest', '>= 4.7'

data/features/authors.md

@@ -29,9 +29,10 @@ The mocking DSL syntax was inspired by the [RR framework][rr].
 
 ## Sponsor
 
-The development of Bogus was partially sponsored by [Lunar Logic][llp].
+The development of Bogus was partially sponsored by [GunpowderLabs][gunpowderlabs] and [Lunar Logic][llp].
 
 [llp]: http://www.lunarlogicpolska.com
+[gunpowderlabs]: http://www.gunpowderlabs.com
 
 [psyho]: https://github.com/psyho
 [apohorecki]: http://twitter.com/apohorecki

data/features/changelog.md

@@ -1,3 +1,11 @@
+## 0.1.6
+
+- Removed dependency on Coveralls::SimpleCov::Formatter (thanks to Ken Dreyer)
+- Made all tests pass on Rubinious
+- Updated tests to use RSpec Mocks instead of RR in unit tests
+- Updated tests to use RSpec 3
+- Fixed described_class in RSpec 3.*
+
 ## 0.1.5
 
 - Made it possible to use fake objects in case/when statements (override ===)

data/features/contract_tests/contract_tests_mocks.feature

@@ -77,7 +77,7 @@ Feature: Contract tests with mocks
 
         library.checkout("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
     end
     """
@@ -95,11 +95,11 @@ Feature: Contract tests with mocks
       it "allows checking out books that are in the inventory" do
         library.return("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_true
+        expect(library.has_book?("Moby Dick")).to be(true)
       end
 
       it "does not allow checking out unavailable books" do
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
 
       it "marks books as unavailable after they are checked out" do
@@ -107,7 +107,7 @@ Feature: Contract tests with mocks
 
         library.checkout("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
     end
     """

data/features/contract_tests/contract_tests_stubs.feature

@@ -90,7 +90,7 @@ Feature: Contract tests with stubs
 
         library.checkout("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
     end
     """
@@ -108,11 +108,11 @@ Feature: Contract tests with stubs
       it "allows checking out books that are in the inventory" do
         library.return("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_true
+        expect(library.has_book?("Moby Dick")).to be(true)
       end
 
       it "does not allow checking out unavailable books" do
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
 
       it "marks books as unavailable after they are checked out" do
@@ -120,7 +120,7 @@ Feature: Contract tests with stubs
 
         library.checkout("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
     end
     """

data/features/contract_tests/custom_overwritten_class.feature

@@ -95,11 +95,11 @@ Feature: Customizing the overwritten class
       it "allows checking out books that are in the inventory" do
         library.return("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_true
+        expect(library.has_book?("Moby Dick")).to be(true)
       end
 
       it "does not allow checking out unavailable books" do
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
 
       it "marks books as unavailable after they are checked out" do
@@ -107,7 +107,7 @@ Feature: Customizing the overwritten class
 
         library.checkout("Moby Dick")
 
-        expect(library.has_book?("Moby Dick")).to be_false
+        expect(library.has_book?("Moby Dick")).to be(false)
       end
     end
     """

data/features/fakes/fake_objects.feature

@@ -60,7 +60,7 @@ Feature: Faking existing classes
       fake(:library)
 
       it "does something" do
-        expect(Student.learn(library)).to be_true
+        expect(Student.learn(library)).to be(true)
       end
     end
     """
@@ -140,7 +140,7 @@ Feature: Faking existing classes
       fake(:library)
 
       it "is identified as Library" do
-        expect(library?(library)).to be_true
+        expect(library?(library)).to be(true)
       end
     end
     """

data/lib/bogus/core_ext.rb

@@ -1,5 +1,5 @@
 # This monkey patch should not break Ruby compatibility
-# but is necessary because MRI, insead of calling object.kind_of?(module),
+# but is necessary because MRI, instead of calling object.kind_of?(module),
 # calls the C function, which implements kind_of. This makes
 # using fake objects in switch cases produce unexpected results:
 #
@@ -15,7 +15,11 @@
 class Module
   # don't warn about redefining === method
   Bogus::Support.supress_warnings do
+    alias :__trequals__ :===
+
     def ===(object)
+      # BasicObjects do not have kind_of? method
+      return __trequals__(object) unless Object.__trequals__(object)
       object.kind_of?(self)
     end
   end

data/lib/bogus/fakes/method_stringifier.rb

@@ -27,12 +27,12 @@ module Bogus
 
     def argument_to_string(name, type, default)
       case type
-      when :block then "&#{name}"
+      when :block then "&#{name == :& ? 'block' : name}"
       when :key then default ? "#{name}: #{default}" : "#{name}: #{name}"
       when :keyreq then default ? "#{name}:" : "#{name}: #{name}"
       when :opt then default ? "#{name} = #{default}" : name
       when :req then name
-      when :rest then "*#{name}"
+      when :rest then "*#{name == :* ? 'rest' : name}"
       when :keyrest then "**#{name}"
       else raise "unknown argument type: #{type}"
       end

data/lib/bogus/minitest/syntax.rb

@@ -17,8 +17,8 @@ module Bogus
 
     def after_suite(&block)
       # minitest 5 vs 4.7
-      if defined? Minitest.after_run
-        Minitest.after_run(&block)
+      if defined? ::Minitest.after_run
+        ::Minitest.after_run(&block)
       else
         MiniTest::Unit.after_tests(&block)
       end

data/lib/bogus/minitest.rb

@@ -38,8 +38,8 @@ module Bogus::Minitest
 end
 
 # minitest 5 vs 4.7
-if defined? Minitest::Test
-  class Minitest::Test
+if defined? ::Minitest::Test
+  class ::Minitest::Test
     include Bogus::Minitest
   end
 else

data/lib/bogus/rspec/syntax.rb

@@ -8,6 +8,9 @@ module Bogus
     def_delegators :context, :before, :after, :described_class
 
     def described_class=(value)
+      # for new RSpec (> 3.0)
+      context.metadata[:described_class] = value
+      # for old RSpec (< 3.0)
       context.example.metadata[:example_group][:described_class] = value
     end
 

data/lib/bogus/stubbing/verifies_stub_definition.rb

@@ -8,12 +8,17 @@ module Bogus
       stubbing_non_existent_method!(object, method_name) unless object.respond_to?(method_name)
       return unless object.methods.include?(method_name)
       return if WithArguments.with_matcher?(args)
-      method = object.method(method_name)
+      method = get_method_object(object, method_name)
       verify_call!(method, args)
     end
 
     private
 
+    def get_method_object(object, method_name)
+      return object.instance_method(:initialize) if constructor?(object, method_name)
+      object.method(method_name)
+    end
+
     def verify_call!(method, args)
       object = Object.new
       fake_method = method_stringifier.stringify(method, "")
@@ -31,5 +36,9 @@ module Bogus
     def stubbing_non_existent_method!(object, method_name)
       raise NameError, "#{object.inspect} does not respond to #{method_name}"
     end
+
+    def constructor?(object, method_name)
+      method_name.to_sym == :new && object.kind_of?(Class)
+    end
   end
 end

data/lib/bogus/version.rb

@@ -1,3 +1,3 @@
 module Bogus
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

data/license.md

@@ -0,0 +1 @@
+features/license.md

data/spec/bogus/bugs/rbx_instance_eval_bug_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Bogus do
+  class SampleForRbxInstanceEval < BasicObject
+    def x
+      3
+    end
+  end
+
+  it "doesn't break #instance_eval on RBX" do
+    result = SampleForRbxInstanceEval.new.instance_eval{x}
+    expect(result).to eq(3)
+  end
+
+  it "does not break === with the monkey patch" do
+    expect(SampleForRbxInstanceEval === SampleForRbxInstanceEval.new).to be(true)
+    expect(BasicObject === SampleForRbxInstanceEval.new).to be(true)
+    expect(Bogus === SampleForRbxInstanceEval.new).to be(false)
+  end
+end

data/spec/bogus/bugs/rbx_jruby_stub_on_class_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class ExampleForRbxJRubyBug
+  def self.bar(argument)
+    argument
+  end
+
+  def self.foo(argument)
+    argument
+  end
+
+  def initialize(*args)
+    args
+  end
+end
+
+describe ExampleForRbxJRubyBug do
+  before do
+    extend Bogus::MockingDSL
+  end
+
+  context '.bar' do
+    specify 'stubbing class twice in example' do
+      stub(ExampleForRbxJRubyBug).bar('same_argument')
+      stub(ExampleForRbxJRubyBug).bar('same_argument')
+    end
+  end
+
+  context '.foo' do
+    specify 'stubbing class once in example' do
+      stub(ExampleForRbxJRubyBug).foo('same_argument')
+    end
+
+    specify 'stubbing class once in another example' do
+      stub(ExampleForRbxJRubyBug).foo('same_argument')
+    end
+  end
+
+  context '.new' do
+    before  { stub(ExampleForRbxJRubyBug).new(any_args) }
+
+    specify { ExampleForRbxJRubyBug.new(1, 2, 3) }
+    specify { ExampleForRbxJRubyBug.new(1, 2, 3) }
+  end
+end

data/spec/bogus/contracts/adds_contract_verification_spec.rb

@@ -37,7 +37,7 @@ describe Bogus::AddsContractVerification do
     it "verifies the contract in after_suite" do
       syntax.run_after_suite
 
-      expect(verifies_contracts).to have_received.verify(:some_fake)
+      expect(verifies_contracts).to have_received(:verify).with(:some_fake)
     end
   end
 
@@ -49,17 +49,17 @@ describe Bogus::AddsContractVerification do
 
   let(:overwritten_class) { :the_overwritten_class }
 
-  let(:adds_recording) { stub }
-  let(:verifies_contracts) { stub }
-  let(:converts_name_to_class) { stub }
+  let(:adds_recording) { double }
+  let(:verifies_contracts) { double }
+  let(:converts_name_to_class) { double }
   let(:syntax) { FakeSyntax.new(described_class) }
 
   let(:adds_contract_verification) { isolate(Bogus::AddsContractVerification) }
 
   before do
-    stub(adds_recording).add { overwritten_class }
-    stub(verifies_contracts).verify
-    stub(converts_name_to_class).convert { ClassGuessedFromFakeName }
+    allow(adds_recording).to receive(:add) { overwritten_class }
+    allow(verifies_contracts).to receive(:verify)
+    allow(converts_name_to_class).to receive(:convert) { ClassGuessedFromFakeName }
   end
 
   context "with described_class" do
@@ -87,7 +87,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to described_class" do
       syntax.run_before
 
-      expect(adds_recording).to have_received.add(:some_fake, SomeClass)
+      expect(adds_recording).to have_received(:add).with(:some_fake, SomeClass)
     end
   end
 
@@ -119,7 +119,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to custom class" do
       syntax.run_before
 
-      expect(adds_recording).to have_received.add(:some_fake, ClassToOverwrite)
+      expect(adds_recording).to have_received(:add).with(:some_fake, ClassToOverwrite)
     end
   end
 
@@ -148,7 +148,7 @@ describe Bogus::AddsContractVerification do
     it "adds recording to class based on fake name" do
       syntax.run_before
 
-      expect(adds_recording).to have_received.add(:some_fake, ClassGuessedFromFakeName)
+      expect(adds_recording).to have_received(:add).with(:some_fake, ClassGuessedFromFakeName)
     end
   end
 end

data/spec/bogus/contracts/adds_recording_spec.rb

@@ -9,16 +9,16 @@ describe Bogus::AddsRecording do
     end
   end
 
-  let(:create_proxy_class) { stub }
-  let(:overwrites_classes) { stub }
-  let(:overwritten_classes) { stub }
+  let(:create_proxy_class) { double }
+  let(:overwrites_classes) { double }
+  let(:overwritten_classes) { double }
 
   let(:adds_recording) { isolate(Bogus::AddsRecording) }
 
   before do
-    stub(create_proxy_class).call { Object }
-    stub(overwrites_classes).overwrite
-    stub(overwritten_classes).add
+    allow(create_proxy_class).to receive(:call) { Object }
+    allow(overwrites_classes).to receive(:overwrite)
+    allow(overwritten_classes).to receive(:add)
   end
 
   before do
@@ -26,15 +26,15 @@ describe Bogus::AddsRecording do
   end
 
   it "creates the proxy" do
-    expect(create_proxy_class).to have_received.call(:library, SampleModule::Library)
+    expect(create_proxy_class).to have_received(:call).with(:library, SampleModule::Library)
   end
 
   it "swaps the classes" do
-    expect(overwrites_classes).to have_received.overwrite('SampleModule::Library', Object)
+    expect(overwrites_classes).to have_received(:overwrite).with('SampleModule::Library', Object)
   end
 
   it "records the overwritten class, so that it can be later restored" do
-    expect(overwritten_classes).to have_received.add("SampleModule::Library", SampleModule::Library)
+    expect(overwritten_classes).to have_received(:add).with("SampleModule::Library", SampleModule::Library)
   end
 
   it "returns the proxy class" do

data/spec/bogus/contracts/interactions_repository_spec.rb

@@ -10,43 +10,43 @@ describe Bogus::InteractionsRepository do
   it "considers the interaction recorded if it was recorded previously" do
     interactions_repository.record(:foo, :bar, 1, 2, 3)
 
-    expect(recorded?(:foo, :bar, 1, 2, 3)).to be_true
+    expect(recorded?(:foo, :bar, 1, 2, 3)).to be(true)
   end
 
   it "considers the interaction recorded if it returned the same value as passed block" do
     interactions_repository.record(:foo, :bar) { "a result" }
     interaction = Bogus::Interaction.new(:bar, []) { "a result" }
 
-    expect(interactions_repository.recorded?(:foo, interaction)).to be_true
+    expect(interactions_repository.recorded?(:foo, interaction)).to be(true)
   end
 
   it "does not consider any interactions recorded prior to any recordings" do
-    expect(recorded?(:foo, :bar, 1)).to be_false
+    expect(recorded?(:foo, :bar, 1)).to be(false)
   end
 
   it "does not consider the interaction recorded with a different fake name"  do
     interactions_repository.record(:baz, :bar, 1)
 
-    expect(recorded?(:foo, :bar, 1)).to be_false
+    expect(recorded?(:foo, :bar, 1)).to be(false)
   end
 
   it "does not consider the interaction recorded with a different method name" do
     interactions_repository.record(:foo, :baz, 1)
 
-    expect(recorded?(:foo, :bar, 1)).to be_false
+    expect(recorded?(:foo, :bar, 1)).to be(false)
   end
 
   it "does not consider the interaction recorded with different method arguments" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    expect(recorded?(:foo, :bar, 1)).to be_false
+    expect(recorded?(:foo, :bar, 1)).to be(false)
   end
 
   it "returns a list of interactions for given fake" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
     interactions = interactions_repository.for_fake(:foo)
-    expect(interactions).to have(1).item
+    expect(interactions.size).to eq(1)
     expect(interactions.first.method).to eq :bar
     expect(interactions.first.args).to eq [1, 2]
   end
@@ -54,36 +54,36 @@ describe Bogus::InteractionsRepository do
   it "ignores arguments if the checked interaction has any_args" do
     interactions_repository.record(:foo, :bar, 1)
 
-    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be_true
+    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be(true)
   end
 
   it "takes method name into account when matching interaction with wildcard arguments" do
     interactions_repository.record(:foo, :baz, 1)
 
-    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be_false
+    expect(recorded?(:foo, :bar, Bogus::AnyArgs)).to be(false)
   end
 
   it "ignores arguments if the recorded interaction was recorded with wildcard argument" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_true
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be(true)
   end
 
   it "takes other arguments into account when matching interactions with wildcards" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    expect(recorded?(:foo, :bar, 2, Bogus::Anything)).to be_false
+    expect(recorded?(:foo, :bar, 2, Bogus::Anything)).to be(false)
   end
 
   it "ignores arguments if the checked interaction has any_args" do
     interactions_repository.record(:foo, :bar, 1, 2)
 
-    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_true
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be(true)
   end
 
   it "takes method name into account when matching interaction with wildcard arguments" do
     interactions_repository.record(:foo, :baz, 1, 2)
 
-    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be_false
+    expect(recorded?(:foo, :bar, 1, Bogus::Anything)).to be(false)
   end
 end

data/spec/bogus/contracts/records_double_interactions_spec.rb

@@ -1,25 +1,27 @@
 require 'spec_helper'
 
 describe Bogus::RecordsDoubleInteractions do
-  let(:fake_registry) { stub }
-  let(:doubled_interactions) { stub }
+  let(:fake_registry) { double }
+  let(:doubled_interactions) { double }
   let(:object) { Object.new }
 
   let(:records_double_interactions) { isolate(Bogus::RecordsDoubleInteractions) }
 
   it "records the call in double interaction repository" do
-    stub(fake_registry).name(object) { :object_name }
-    stub(doubled_interactions).record
+    allow(fake_registry).to receive(:name).with(object) { :object_name }
+    allow(doubled_interactions).to receive(:record)
 
     records_double_interactions.record(object, :method_name, [:foo, 1])
 
-    expect(doubled_interactions).to have_received.record(:object_name, :method_name, :foo, 1)
+    expect(doubled_interactions).to have_received(:record).with(:object_name, :method_name, :foo, 1)
   end
 
   it "does not record the interaction if object is not a fake" do
-    stub(fake_registry).name(object) { nil }
-    dont_allow(doubled_interactions).record
+    allow(fake_registry).to receive(:name).with(object) { nil }
+    allow(doubled_interactions).to receive(:record)
 
     records_double_interactions.record(object, :method_name, [:foo, 1])
+
+    expect(doubled_interactions).not_to have_received(:record)
   end
 end

data/spec/bogus/contracts/verifies_contracts_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Bogus::VerifiesContracts do
-  let(:real_interactions) { stub }
-  let(:doubled_interactions) { stub }
+  let(:real_interactions) { double }
+  let(:doubled_interactions) { double }
   let(:verifies_contracts) { isolate(Bogus::VerifiesContracts) }
 
   let(:matched_interaction) { interaction("matched") }
@@ -12,12 +12,12 @@ describe Bogus::VerifiesContracts do
     second_interaction = interaction("second")
     other_interaction = interaction("other")
 
-    stub(doubled_interactions).for_fake(:fake_name){[first_interaction, matched_interaction, second_interaction]}
-    stub(real_interactions).for_fake(:fake_name){[matched_interaction, other_interaction]}
+    allow(doubled_interactions).to receive(:for_fake).with(:fake_name){[first_interaction, matched_interaction, second_interaction]}
+    allow(real_interactions).to receive(:for_fake).with(:fake_name){[matched_interaction, other_interaction]}
 
-    stub(real_interactions).recorded?(:fake_name, first_interaction) { false }
-    stub(real_interactions).recorded?(:fake_name, second_interaction) { false }
-    stub(real_interactions).recorded?(:fake_name, matched_interaction) { true }
+    allow(real_interactions).to receive(:recorded?).with(:fake_name, first_interaction) { false }
+    allow(real_interactions).to receive(:recorded?).with(:fake_name, second_interaction) { false }
+    allow(real_interactions).to receive(:recorded?).with(:fake_name, matched_interaction) { true }
 
     expect_verify_to_raise_error_with_interactions(:fake_name,
                                                    [first_interaction, second_interaction],
@@ -25,8 +25,8 @@ describe Bogus::VerifiesContracts do
   end
 
   it "passes with all calls matched" do
-    stub(doubled_interactions).for_fake(:fake_name) { [matched_interaction] }
-    stub(real_interactions).recorded?(:fake_name, matched_interaction) { true }
+    allow(doubled_interactions).to receive(:for_fake).with(:fake_name) { [matched_interaction] }
+    allow(real_interactions).to receive(:recorded?).with(:fake_name, matched_interaction) { true }
 
     expect {
       verifies_contracts.verify(:fake_name)