bogus 0.1.5 → 0.1.7

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
@@ -81,7 +81,7 @@ describe Bogus::FakeConfiguration do
       end
 
       block = stubs(:foo)[:bar]
-      expect{ block.call }.to raise_error
+      expect{ block.call }.to raise_error RuntimeError
     end
   end
 

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)

data/spec/bogus/mocking_dsl_spec.rb

@@ -239,7 +239,9 @@ describe Bogus::MockingDSL do
   end
 
   describe "#fake" do
-    include Bogus::MockingDSL
+    before do
+      extend Bogus::MockingDSL
+    end
 
     it "creates objects that can be stubbed" do
       greeter = fake

data/spec/bogus/rspec/syntax_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Bogus::RSpecSyntax do
+  context = self
+  let(:syntax) { Bogus::RSpecSyntax.new(context) }
+
+  it "gets the described class" do
+    expect(syntax.described_class).to eq(Bogus::RSpecSyntax)
+  end
+
+  it "can set the described class" do
+    syntax.described_class = Object
+
+    expect(described_class).to eq(Object)
+  end
+end

data/spec/bogus/ruby_2_1_support_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
-if RUBY_VERSION >= '2.1'
+if RubyFeatures.required_keyword_arguments?
   describe "Ruby 2.1 required keyword arguments" do
     class ExampleForRequiredKeywordArgs
       eval "def foo(x:); end"
       eval "def bar(x:, **rest); end"
     end
 
-    include Bogus::MockingDSL
+    before do
+      extend Bogus::MockingDSL
+    end
 
     context "with regular objects" do
       subject { ExampleForRequiredKeywordArgs.new }

data/spec/bogus/ruby_2_support_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
-if RUBY_VERSION >= '2.0'
+if RubyFeatures.keyword_arguments?
   describe "Ruby 2.0 keyword arguments" do
     class ExampleForKeywordArgs
       eval "def foo(x: 1); end"
       eval "def bar(x: 1, **rest); end"
     end
 
-    include Bogus::MockingDSL
+    before do
+      extend Bogus::MockingDSL
+    end
 
     context "with regular objects" do
       subject { ExampleForKeywordArgs.new }

data/spec/bogus/stubbing/double_spec.rb

@@ -4,59 +4,59 @@ module Bogus
   describe Double do
     shared_examples_for "double behavior" do
       it "tracks existence of test doubles" do
-        mock(double_tracker).track(object)
+        expect(double_tracker).to receive(:track).with(object)
 
-        double.stub.foo("a", "b") { "the result" }
+        double_instance.stub.foo("a", "b") { "the result" }
       end
 
       it "does not track existence of the double if verify fails" do
-        stub(verifies_stub_definition).verify!(object, :foo, ["a", "b"]) { raise NameError }
+        allow(verifies_stub_definition).to receive(:verify!).with(object, :foo, ["a", "b"]) { raise NameError }
 
         expect {
-          double.stub.foo("a", "b") { "the result" }
-        }.to raise_error
+          double_instance.stub.foo("a", "b") { "the result" }
+        }.to raise_error NameError
 
-        expect(double_tracker).not_to have_received.track(object)
+        expect(double_tracker).not_to have_received(:track).with(object)
       end
 
       it "verifies stub definition" do
-        mock(verifies_stub_definition).verify!(object, :foo, ["a", "b"])
+        expect(verifies_stub_definition).to receive(:verify!).with(object, :foo, ["a", "b"])
 
-        double.stub.foo("a", "b") { "the result" }
+        double_instance.stub.foo("a", "b") { "the result" }
       end
 
       it "stubs shadow methods" do
         object.extend RecordInteractions
-        mock(object.__shadow__).stubs(:foo, "a", "b")
+        expect(object.__shadow__).to receive(:stubs).with(:foo, "a", "b")
 
-        double.stub.foo("a", "b") { "the result" }
+        double_instance.stub.foo("a", "b") { "the result" }
       end
 
       it "mocks shadow methods" do
         object.extend RecordInteractions
-        mock(object.__shadow__).mocks(:foo, "a", "b")
+        expect(object.__shadow__).to receive(:mocks).with(:foo, "a", "b")
 
-        double.mock.foo("a", "b") { "the result" }
+        double_instance.mock.foo("a", "b") { "the result" }
       end
 
       it "adds method overwriting" do
-        double.stub.foo("a", "b") { "the result" }
+        double_instance.stub.foo("a", "b") { "the result" }
 
         expect(overwrites_methods.overwrites).to eq([[object, :foo]])
       end
 
       it "records double interactions" do
-        mock(records_double_interactions).record(object, :foo, ["a", "b"])
+        expect(records_double_interactions).to receive(:record).with(object, :foo, ["a", "b"])
 
-        double.stub.foo("a", "b") { "the result" }
+        double_instance.stub.foo("a", "b") { "the result" }
       end
     end
 
-    let(:double_tracker) { stub(track: nil) }
-    let(:verifies_stub_definition) { stub(verify!: nil) }
-    let(:records_double_interactions) { stub(record: nil) }
+    let(:double_tracker) { double(:double_tracker, track: nil) }
+    let(:verifies_stub_definition) { double(:verifies_stub_definition, verify!: nil) }
+    let(:records_double_interactions) { double(:records_double_interactions, record: nil) }
     let(:overwrites_methods) { FakeMethodOverwriter.new }
-    let(:double) { isolate(Double) }
+    let(:double_instance) { isolate(Double) }
 
     context "with regular objects" do
       let(:object) { Samples::Foo.new }

data/spec/bogus/stubbing/have_received_matcher_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
 describe Bogus::HaveReceivedMatcher do
-  let(:verifies_stub_definition) { stub(verify!: nil) }
-  let(:records_double_interactions) { stub(record: nil) }
+  let(:verifies_stub_definition) { double(:verifies_stub_definition, verify!: nil) }
+  let(:records_double_interactions) { double(:records_double_interactions, record: nil) }
   let(:have_received_matcher) { isolate(Bogus::HaveReceivedMatcher) }
-  let(:have_received) { have_received_matcher.method_call }
   let(:fake) { Samples::FooFake.new }
 
   before do
@@ -13,33 +12,33 @@ describe Bogus::HaveReceivedMatcher do
 
   shared_examples_for "have_received_matcher" do
     it "matches when the spy has received the message" do
-      expect(fake).to have_received(:foo, "a", "b")
+      expect(fake).to bogus_have_received(:foo, "a", "b")
     end
 
     it "does not match if the spy hasn't received the message" do
-      expect(fake).not_to have_received(:foo, "a", "c")
+      expect(fake).not_to bogus_have_received(:foo, "a", "c")
     end
 
     it "verifies that the method call has the right signature" do
-      mock(verifies_stub_definition).verify!(fake, :foo, ["a", "b"])
+      expect(verifies_stub_definition).to receive(:verify!).with(fake, :foo, ["a", "b"])
 
-      have_received(:foo, "a", "b")
+      bogus_have_received(:foo, "a", "b")
 
       have_received_matcher.matches?(fake)
     end
 
     it "records the interaction so that it can be checked by contract tests" do
-      mock(records_double_interactions).record(fake, :foo, ["a", "b"])
+      expect(records_double_interactions).to receive(:record).with(fake, :foo, ["a", "b"])
 
-      have_received(:foo, "a", "b")
+      bogus_have_received(:foo, "a", "b")
 
       have_received_matcher.matches?(fake)
     end
 
     it "returns a readable error message for object with no shadow" do
-      have_received(:upcase)
+      bogus_have_received(:upcase)
 
-      expect(have_received_matcher.matches?("foo")).to be_false
+      expect(have_received_matcher.matches?("foo")).to be(false)
       expect(have_received_matcher.failure_message_for_should).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
       expect(have_received_matcher.failure_message).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
       expect(have_received_matcher.failure_message_for_should_not).to eq(Bogus::HaveReceivedMatcher::NO_SHADOW)
@@ -47,7 +46,7 @@ describe Bogus::HaveReceivedMatcher do
     end
 
     it "returns a readable error message for fakes" do
-      have_received(:foo, "a", "c")
+      bogus_have_received(:foo, "a", "c")
 
       have_received_matcher.matches?(fake)
 
@@ -62,7 +61,7 @@ describe Bogus::HaveReceivedMatcher do
   end
 
   context "with method_missing builder" do
-    def have_received(method, *args)
+    def bogus_have_received(method, *args)
       have_received_matcher.build.__send__(method, *args)
     end
 
@@ -70,7 +69,7 @@ describe Bogus::HaveReceivedMatcher do
   end
 
   context "with method call builder" do
-    def have_received(*args)
+    def bogus_have_received(*args)
       have_received_matcher.build(*args)
     end