bogus 0.1.5 → 0.1.6

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)

data/spec/bogus/fakes/copies_classes_spec.rb

@@ -125,15 +125,15 @@ describe Bogus::CopiesClasses do
     end
 
     it "should override kind_of?" do
-      expect(fake.kind_of?(SomeModule::SomeClass)).to be_true
+      expect(fake.kind_of?(SomeModule::SomeClass)).to be(true)
     end
 
     it "should override instance_of?" do
-      expect(fake.instance_of?(SomeModule::SomeClass)).to be_true
+      expect(fake.instance_of?(SomeModule::SomeClass)).to be(true)
     end
 
     it "should override is_a?" do
-      expect(fake.is_a?(SomeModule::SomeClass)).to be_true
+      expect(fake.is_a?(SomeModule::SomeClass)).to be(true)
     end
 
     it "should include class name in the output of fake's class #to_s" do
@@ -145,13 +145,13 @@ describe Bogus::CopiesClasses do
     end
 
     it 'should override ===' do
-      expect(SomeModule::SomeClass === fake).to be_true
+      expect(SomeModule::SomeClass === fake).to be(true)
     end
   end
 
   shared_examples_for 'spying' do
     def should_record(method, *args)
-      mock(subject).__record__(method, *args)
+      expect(subject).to receive(:__record__).with(method, *args)
 
       subject.send(method, *args)
     end

data/spec/bogus/fakes/creates_fakes_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe Bogus::CreatesFakes do
-  let(:fake_class) { stub }
-  let(:fake_instance) { stub }
-  let(:converts_name_to_class) { stub }
-  let(:copies_classes) { stub }
-  let(:makes_ducks) { stub }
+  let(:fake_class) { double }
+  let(:fake_instance) { double }
+  let(:converts_name_to_class) { double }
+  let(:copies_classes) { double }
+  let(:makes_ducks) { double }
   let(:creates_fakes) { isolate(Bogus::CreatesFakes) }
 
   module Foo
@@ -14,12 +14,12 @@ describe Bogus::CreatesFakes do
   module Bar
   end
 
-  before { stub(fake_class).__create__{fake_instance} }
+  before { allow(fake_class).to receive(:__create__){fake_instance} }
 
   context "without block" do
     before do
-      mock(converts_name_to_class).convert(:foo) { Foo }
-      mock(copies_classes).copy(Foo) { fake_class }
+      expect(converts_name_to_class).to receive(:convert).with(:foo) { Foo }
+      expect(copies_classes).to receive(:copy).with(Foo) { fake_class }
     end
 
     it "creates a new instance of copied class by default" do
@@ -43,8 +43,8 @@ describe Bogus::CreatesFakes do
 
   context "with block" do
     before do
-      stub(converts_name_to_class).convert
-      mock(copies_classes).copy(Bar) { fake_class }
+      allow(converts_name_to_class).to receive(:convert)
+      expect(copies_classes).to receive(:copy).with(Bar) { fake_class }
     end
 
     it "uses the class provided" do
@@ -54,7 +54,7 @@ describe Bogus::CreatesFakes do
     it "does not convert the class name" do
       creates_fakes.create(:foo) { Bar}
 
-      expect(copies_classes).to_not have_received.convert
+      expect(converts_name_to_class).not_to have_received(:convert)
     end
   end
 
@@ -63,8 +63,8 @@ describe Bogus::CreatesFakes do
 
   context "with multiple classes" do
     it "creates a duck type out of those classes and fakes it" do
-      stub(makes_ducks).make(Foo, Bar) { FooBarDuck }
-      stub(copies_classes).copy(FooBarDuck) { :the_fake }
+      allow(makes_ducks).to receive(:make).with(Foo, Bar) { FooBarDuck }
+      allow(copies_classes).to receive(:copy).with(FooBarDuck) { :the_fake }
 
       fake = creates_fakes.create(:role, as: :class) { [Foo, Bar] }
 

data/spec/bogus/fakes/creates_fakes_with_stubbed_methods_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 module Bogus
   describe CreatesFakesWithStubbedMethods do
     let(:creates_fakes) { FakeCreatorOfFakes.new }
-    let(:fake_configuration) { stub }
-    let(:responds_to_everything) { stub }
-    let(:multi_stubber) { stub }
+    let(:fake_configuration) { double }
+    let(:responds_to_everything) { double }
+    let(:multi_stubber) { double }
 
     let(:creates_anonymous_stubs) { isolate(CreatesFakesWithStubbedMethods) }
 
     before do
-      stub(fake_configuration).include? { false }
-      stub(multi_stubber).stub_all { :stubbed_object }
+      allow(fake_configuration).to receive(:include?) { false }
+      allow(multi_stubber).to receive(:stub_all) { :stubbed_object }
     end
 
     context "given symbol as first parameter" do
@@ -26,7 +26,7 @@ module Bogus
       end
 
       it "stubs all the given methods" do
-        expect(multi_stubber).to have_received.stub_all(fake, bar: 1)
+        expect(multi_stubber).to have_received(:stub_all).with(fake, bar: 1)
       end
     end
 
@@ -40,7 +40,7 @@ module Bogus
       end
 
       it "stubs all the given methods" do
-        expect(multi_stubber).to have_received.stub_all(responds_to_everything, bar: 1)
+        expect(multi_stubber).to have_received(:stub_all).with(responds_to_everything, bar: 1)
       end
     end
 
@@ -56,7 +56,7 @@ module Bogus
       end
 
       it "stubs all the given methods" do
-        expect(multi_stubber).to have_received.stub_all(fake, {})
+        expect(multi_stubber).to have_received(:stub_all).with(fake, {})
       end
     end
 
@@ -70,7 +70,7 @@ module Bogus
       end
 
       it "stubs all the given methods" do
-        expect(multi_stubber).to have_received.stub_all(responds_to_everything, {})
+        expect(multi_stubber).to have_received(:stub_all).with(responds_to_everything, {})
       end
     end
 
@@ -78,8 +78,8 @@ module Bogus
       let(:fake) { [:foo, {as: :class}, "SomeClass"] }
 
       before do
-        stub(fake_configuration).include?(:foo) { true }
-        stub(fake_configuration).get(:foo) { FakeDefinition.new(opts: {as: :class},
+        allow(fake_configuration).to receive(:include?).with(:foo) { true }
+        allow(fake_configuration).to receive(:get).with(:foo) { FakeDefinition.new(opts: {as: :class},
                                                                 stubs: {xyz: "abc"},
                                                                 class_block: proc{"SomeClass"}) }
 
@@ -89,12 +89,12 @@ module Bogus
       it "uses the configuration to create fake" do
         expect(creates_fakes.fakes).to eq [fake]
 
-        expect(fake_configuration).to have_received.include?(:foo)
-        expect(fake_configuration).to have_received.get(:foo)
+        expect(fake_configuration).to have_received(:include?).with(:foo)
+        expect(fake_configuration).to have_received(:get).with(:foo)
       end
 
       it "stubs the methods defined in configuration" do
-        expect(multi_stubber).to have_received.stub_all(fake, xyz: "abc")
+        expect(multi_stubber).to have_received(:stub_all).with(fake, xyz: "abc")
       end
     end
 
@@ -102,10 +102,12 @@ module Bogus
       let(:fake) { [:foo, {as: :instance}, "SomeOtherClass"] }
 
       before do
-        stub(fake_configuration).include?(:foo) { true }
-        stub(fake_configuration).get(:foo) { FakeDefinition.new(opts: {as: :class},
-                                                                stubs: {a: "b", b: "c"},
-                                                                class_block: proc{"SomeClass"}) }
+        allow(fake_configuration).to receive(:include?).with(:foo) { true }
+        allow(fake_configuration).to receive(:get).with(:foo) {
+          FakeDefinition.new(opts: {as: :class},
+                             stubs: {a: "b", b: "c"},
+                             class_block: proc{"SomeClass"})
+        }
 
         creates_anonymous_stubs.create(:foo, as: :instance, b: "d", c: "e") { "SomeOtherClass" }
       end
@@ -115,7 +117,7 @@ module Bogus
       end
 
       it "overrides the stubbed methods" do
-        expect(multi_stubber).to have_received.stub_all(fake, a: "b", b: "d", c: "e")
+        expect(multi_stubber).to have_received(:stub_all).with(fake, a: "b", b: "d", c: "e")
       end
     end
   end

data/spec/bogus/fakes/fake_ar_attributes_spec.rb

@@ -19,7 +19,9 @@ describe "Stubbing ActiveRecord::Base subclasses" do
     end
   end
 
-  include Bogus::MockingDSL
+  before do
+    extend Bogus::MockingDSL
+  end
 
   before do
     Bogus.configure do |c|

data/spec/bogus/fakes/fake_configuration_spec.rb

@@ -4,7 +4,7 @@ describe Bogus::FakeConfiguration do
   let(:config) { Bogus::FakeConfiguration.new }
 
   it "does not contain not configured fakes" do
-    expect(config.include?(:foo)).to be_false
+    expect(config.include?(:foo)).to be(false)
   end
 
   def class_block(name)
@@ -26,8 +26,8 @@ describe Bogus::FakeConfiguration do
       end
     end
 
-    expect(config.include?(:foo)).to be_true
-    expect(config.include?(:bar)).to be_false
+    expect(config.include?(:foo)).to be(true)
+    expect(config.include?(:bar)).to be(false)
   end
 
   it "returns the configuration for a fake" do

data/spec/bogus/fakes/fakes_classes_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Bogus::FakesClasses do
   let(:creates_fakes_with_stubbed_methods) { FakeCreatorOfFakes.new }
-  let(:overwrites_classes) { stub }
-  let(:overwritten_classes) { stub }
+  let(:overwrites_classes) { double }
+  let(:overwritten_classes) { double }
 
   let(:fakes_classes) { isolate(Bogus::FakesClasses) }
 
@@ -13,8 +13,8 @@ describe Bogus::FakesClasses do
   end
 
   before do
-    stub(overwrites_classes).overwrite
-    stub(overwritten_classes).add
+    allow(overwrites_classes).to receive(:overwrite)
+    allow(overwritten_classes).to receive(:add)
   end
 
   it "creates a fake named after the class" do
@@ -29,13 +29,13 @@ describe Bogus::FakesClasses do
 
     fakes_classes.fake(Samples::WillBeOverwritten)
 
-    expect(overwrites_classes).to have_received.overwrite("Samples::WillBeOverwritten", fake)
+    expect(overwrites_classes).to have_received(:overwrite).with("Samples::WillBeOverwritten", fake)
   end
 
   it "stores the overwritten class so that it can be replaced back later" do
     fakes_classes.fake(Samples::WillBeOverwritten)
 
-    expect(overwritten_classes).to have_received.add("Samples::WillBeOverwritten", Samples::WillBeOverwritten)
+    expect(overwritten_classes).to have_received(:add).with("Samples::WillBeOverwritten", Samples::WillBeOverwritten)
   end
 
   it "uses the passed fake name if provided" do

data/spec/bogus/fakes/faking_factories_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe "Faking Factories" do
-  include Bogus::MockingDSL
+  before do
+    extend Bogus::MockingDSL
+  end
 
   class ExampleFactory
     def initialize(model_class)

data/spec/bogus/fakes/frozen_fakes_spec.rb

@@ -1,7 +1,9 @@
 require "spec_helper"
 
 describe "Frozen Fakes" do
-  include Bogus::MockingDSL
+  before do
+    extend Bogus::MockingDSL
+  end
 
   class ExampleForFreezing
     def foo(x)

data/spec/bogus/fakes/registers_created_fakes_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
 describe Bogus::RegistersCreatedFakes do
-  let(:fake_registry) { stub }
-  let(:creates_fakes) { stub }
-  let(:double_tracker) { stub }
+  let(:fake_registry) { double }
+  let(:creates_fakes) { double }
+  let(:double_tracker) { double }
 
   let(:registers_created_fakes) { isolate(Bogus::RegistersCreatedFakes) }
 
   before do
-    stub(fake_registry).store
-    stub(creates_fakes).create { :the_fake }
-    stub(double_tracker).track(:the_fake)
+    allow(fake_registry).to receive(:store)
+    allow(creates_fakes).to receive(:create) { :the_fake }
+    allow(double_tracker).to receive(:track).with(:the_fake)
   end
 
   it "registers the fakes created by creates_fakes" do
     registers_created_fakes.create(:foo, as: :instance) { Object }
 
-    expect(fake_registry).to have_received.store(:foo, :the_fake)
+    expect(fake_registry).to have_received(:store).with(:foo, :the_fake)
   end
 
   it "tracks the created fakes for purposes of mock expectations" do
     registers_created_fakes.create(:foo, as: :instance) { Object }
 
-    expect(double_tracker).to have_received.track(:the_fake)
+    expect(double_tracker).to have_received(:track).with(:the_fake)
   end
 
   it "returns the created fake" do

data/spec/bogus/fakes/resets_overwritten_classes_spec.rb

@@ -2,25 +2,25 @@ require 'spec_helper'
 
 describe Bogus::ResetsOverwrittenClasses do
   let(:classes) { [['Foo', :foo], ['Bar', :bar]] }
-  let(:overwritten_classes) { stub }
-  let(:overwrites_classes) { stub }
+  let(:overwritten_classes) { double }
+  let(:overwrites_classes) { double }
 
   let(:resets_overwritten_classes) { isolate(Bogus::ResetsOverwrittenClasses) }
 
   before do
-    stub(overwritten_classes).classes { classes }
-    stub(overwritten_classes).clear
-    stub(overwrites_classes).overwrite
+    allow(overwritten_classes).to receive(:classes) { classes }
+    allow(overwritten_classes).to receive(:clear)
+    allow(overwrites_classes).to receive(:overwrite)
 
     resets_overwritten_classes.reset
   end
 
   it "overwrites back all of the overwritten classes" do
-    expect(overwrites_classes).to have_received.overwrite('Foo', :foo)
-    expect(overwrites_classes).to have_received.overwrite('Bar', :bar)
+    expect(overwrites_classes).to have_received(:overwrite).with('Foo', :foo)
+    expect(overwrites_classes).to have_received(:overwrite).with('Bar', :bar)
   end
 
   it "clears the overwritten classes" do
-    expect(overwritten_classes).to have_received.clear
+    expect(overwritten_classes).to have_received(:clear)
   end
 end

data/spec/bogus/fakes/stubbing_new_method_on_fake_class_spec.rb

@@ -4,7 +4,9 @@ describe "Stubbing .new on fake class" do
   class ExampleForStubbingNew
   end
 
-  include Bogus::MockingDSL
+  before do
+    extend Bogus::MockingDSL
+  end
 
   it "allows stubbing new on a class" do
     fake_class = fake(ExampleForStubbingNew, as: :class)