bogus 0.1.5 → 0.1.6

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" }
+          double_instance.stub.foo("a", "b") { "the result" }
         }.to raise_error
 
-        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
 

data/spec/bogus/stubbing/interaction_spec.rb

@@ -52,7 +52,7 @@ module Bogus
         first = create_interaction(first_interaction)
         second = create_interaction(second_interaction)
 
-        expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be(true)
       end
     end
 
@@ -61,7 +61,7 @@ module Bogus
         first = create_interaction(first_interaction)
         second = create_interaction(second_interaction)
 
-        expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be(false)
       end
     end
 
@@ -69,21 +69,21 @@ module Bogus
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { nil }
 
-      expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be(false)
     end
 
     it "differs raised exceptions from ones just returned from the block" do
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { SomeError }
 
-      expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be(false)
     end
 
     it "considers exceptions of the same type as equal" do
       first = Interaction.new(:foo, [:bar]) { raise SomeError }
       second = Interaction.new(:foo, [:bar]) { raise SomeError }
 
-      expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
+      expect(Interaction.same?(recorded: first, stubbed: second)).to be(true)
     end
 
     context 'when comparing arguments with custom #== implementations' do
@@ -97,14 +97,14 @@ module Bogus
         first = Interaction.new(:with, [Dev.new(:psyho)])
         second = Interaction.new(:with, [Dev.new(:psyho)])
 
-        expect(Interaction.same?(recorded: first, stubbed: second)).to be_true
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be(true)
       end
 
       it "considers two interactions != when the arguments are !=" do
         first = Interaction.new(:with, [Dev.new(:wrozka)])
         second = Interaction.new(:with, [Dev.new(:yundt)])
 
-        expect(Interaction.same?(recorded: first, stubbed: second)).to be_false
+        expect(Interaction.same?(recorded: first, stubbed: second)).to be(false)
       end
     end
   end

data/spec/bogus/stubbing/multi_stubber_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
 describe Bogus::MultiStubber do
-  let(:double) { FakeDouble.new }
-  let(:create_double) { proc{ double } }
-  let(:any_args) { Bogus::AnyArgs }
+  let(:fake_double) { FakeDouble.new }
+  let(:bogus_any_args) { Bogus::AnyArgs }
+  let(:create_double) { proc{ fake_double } }
 
   let(:multi_stubber) { isolate(Bogus::MultiStubber) }
 
   it "stubs all the given methods with any args returning the given value" do
     multi_stubber.stub_all(Object.new, foo: 1, bar: 2)
 
-    expect(double.stubbed).to eq([[:foo, [any_args], 1], [:bar, [any_args], 2]])
+    expect(fake_double.stubbed).to eq([[:foo, [bogus_any_args], 1], [:bar, [bogus_any_args], 2]])
   end
 
   it "uses passed procs as the return value block" do
     multi_stubber.stub_all(Object.new, foo: proc{ 1 })
 
-    expect(double.stubbed).to eq([[:foo, [any_args], 1]])
+    expect(fake_double.stubbed).to eq([[:foo, [bogus_any_args], 1]])
   end
 
   class FakeDouble

data/spec/bogus/stubbing/record_interactions_spec.rb

@@ -11,13 +11,13 @@ describe Bogus::RecordInteractions do
   it "allows verifying that interactions happened" do
     sample.__record__(:foo, 1, 2, 3)
 
-    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be_true
+    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be(true)
   end
 
   it "allows verifying that interactions didn't happen" do
     sample.__record__(:bar)
 
-    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be_false
+    expect(sample.__shadow__.has_received(:foo, [1,2,3])).to be(false)
   end
 
   it "returns self from record by default" do

data/spec/bogus/stubbing/resets_stubbed_methods_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe Bogus::ResetsStubbedMethods do
-  let(:double_tracker) { stub }
-  let(:overwrites_methods) { stub }
+  let(:double_tracker) { double }
+  let(:overwrites_methods) { double }
 
   let(:resets_stubbed_methods) { isolate(Bogus::ResetsStubbedMethods) }
 
   it "resets all stubbed objects back to previous implementation" do
-    foo = stub
-    stub(double_tracker).doubles { [foo] }
-    mock(overwrites_methods).reset(foo)
+    foo = double
+    allow(double_tracker).to receive(:doubles) { [foo] }
+    expect(overwrites_methods).to receive(:reset).with(foo)
 
     resets_stubbed_methods.reset_all_doubles
   end

data/spec/bogus/stubbing/shadow_spec.rb

@@ -11,12 +11,12 @@ describe Bogus::Shadow do
       end
 
       it "returns the called methods" do
-        expect(shadow.has_received(:foo, ["a", "b"])).to be_true
+        expect(shadow.has_received(:foo, ["a", "b"])).to be(true)
       end
 
       it "does not return true for interactions that did not happen" do
-        expect(shadow.has_received(:foo, ["a", "c"])).to be_false
-        expect(shadow.has_received(:bar, ["a", "c"])).to be_false
+        expect(shadow.has_received(:foo, ["a", "c"])).to be(false)
+        expect(shadow.has_received(:bar, ["a", "c"])).to be(false)
       end
     end
   end
@@ -81,7 +81,7 @@ describe Bogus::Shadow do
     it "allows spying on calls using any args" do
       shadow.run(:foo, "a", "c")
 
-      expect(shadow.has_received(:foo, [Bogus::AnyArgs])).to be_true
+      expect(shadow.has_received(:foo, [Bogus::AnyArgs])).to be(true)
     end
   end
 
@@ -103,7 +103,7 @@ describe Bogus::Shadow do
     it "allows spying on calls using anything in args" do
       shadow.run(:foo, "a", "b")
 
-      expect(shadow.has_received(:foo, [Bogus::Anything, "b"])).to be_true
+      expect(shadow.has_received(:foo, [Bogus::Anything, "b"])).to be(true)
     end
   end
 
@@ -177,7 +177,7 @@ describe Bogus::Shadow do
 
     it "contributes towards unsatisfied interactions" do
       interactions = shadow.unsatisfied_interactions
-      expect(interactions).to have(1).item
+      expect(interactions.size).to eq(1)
       expect(interactions.first.method).to eq(:foo)
       expect(interactions.first.args).to eq(["a", "b"])
     end

data/spec/bogus/stubbing/stubbing_existing_methods_on_fakes_spec.rb

@@ -1,9 +1,9 @@
  require 'spec_helper'
 
  describe "Stubbing existing methods on fakes" do
-   include Bogus::MockingDSL
 
    before do
+     extend Bogus::MockingDSL
      Bogus.clear
    end
 

data/spec/spec_helper.rb

@@ -1,14 +1,14 @@
 require 'simplecov'
 begin
   require "coveralls"
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter]
 rescue LoadError
   warn "warning: coveralls gem not found; skipping Coveralls"
+  SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
 end
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter]
-
 SimpleCov.start do
   add_filter "/spec/"
 end
@@ -16,19 +16,12 @@ end
 require 'bogus'
 require 'dependor/rspec'
 
-require 'rr'
-
 require_relative 'support/sample_fake'
 require_relative 'support/fake_creator_of_fakes'
 require_relative 'support/matchers'
 require_relative 'support/shared_examples_for_keyword_arguments'
+require_relative 'support/ruby_features'
 
 RSpec.configure do |config|
-  config.color_enabled = true
-  config.mock_framework = :rr
-end
-
-# this should not be necessary...
-def have_received(method = nil)
-  RR::Adapters::Rspec::InvocationMatcher.new(method)
+  config.mock_with :rspec
 end

data/spec/support/ruby_features.rb

@@ -0,0 +1,19 @@
+module RubyFeatures
+  module_function
+
+  def keyword_arguments?
+    ruby?('2.0') && !rbx?
+  end
+
+  def required_keyword_arguments?
+    ruby?('2.1') && keyword_arguments?
+  end
+
+  def ruby?(version)
+    RUBY_VERSION >= version
+  end
+
+  def rbx?
+    RUBY_ENGINE == 'rbx'
+  end
+end