bogus 0.0.2 → 0.0.3.rc.1

data/lib/bogus/rspec.rb

@@ -3,4 +3,11 @@ require 'bogus'
 RSpec.configure do |config|
   config.extend Bogus::RSpecExtensions
   config.include Bogus::MockingDSL
+
+  config.mock_with Bogus::RSpecAdapter
+  config.backtrace_clean_patterns << Regexp.new("lib/bogus")
+
+  config.after(:suite) do
+    Bogus.reset!
+  end
 end

data/lib/bogus/rspec_adapter.rb

@@ -0,0 +1,17 @@
+module Bogus
+  module RSpecAdapter
+    def setup_mocks_for_rspec
+      # no setup needed
+    end
+
+    def verify_mocks_for_rspec
+      Bogus.ensure_all_expectations_satisfied!
+    end
+
+    def teardown_mocks_for_rspec
+      Bogus.reset_stubbed_methods
+      Bogus.clear_expectations
+      Bogus.reset_overwritten_classes
+    end
+  end
+end

data/lib/bogus/rspec_extensions.rb

@@ -1,12 +1,18 @@
 module Bogus
   module RSpecExtensions
     def fake(name, opts = {}, &block)
-      let(name) { Bogus.fake_for(name, opts, &block) }
+      let(name) { fake(name, opts, &block) }
+    end
+
+    def fake_class(name, opts = {})
+      before do
+        fake_class(name, opts)
+      end
     end
 
     def verify_contract(name)
       before do
-        Bogus.record_calls_for(name)
+        Bogus.record_calls_for(name, described_class)
       end
 
       RSpec.configure do |config|
@@ -14,23 +20,5 @@ module Bogus
       end
     end
   end
-
-  module MockingDSL
-    def fake(*args)
-      Bogus.create_anonymous_stub(*args)
-    end
-
-    def stub(*args)
-      Bogus.create_stub(*args)
-    end
-
-    def have_received(*args)
-      Bogus.have_received(*args)
-    end
-
-    def mock(*args)
-      Bogus.create_mock(*args)
-    end
-  end
 end
 

data/lib/bogus/shadow.rb

@@ -0,0 +1,60 @@
+module Bogus
+  class Shadow
+    attr_reader :calls
+
+    def initialize(&default_return_value)
+      @calls = []
+      @stubs = []
+      @defaults = Hash.new(default_return_value)
+      @required = Set.new
+    end
+
+    def run(method_name, *args)
+      interaction = Interaction.new(method_name, args)
+      @calls << interaction
+      return_value(interaction)
+    end
+
+    def has_received(name, args)
+      @calls.include?(Interaction.new(name, args))
+    end
+
+    def stubs(name, *args, &return_value)
+      interaction = Interaction.new(name, args)
+      add_stub(interaction, return_value)
+      override_default(interaction, return_value)
+      @required.delete(interaction)
+      interaction
+    end
+
+    def mocks(name, *args, &return_value)
+      interaction = stubs(name, *args, &return_value)
+      @required.add(interaction)
+    end
+
+    def unsatisfied_interactions
+      @required.to_a - @calls
+    end
+
+    def self.has_shadow?(object)
+      object.respond_to?(:__shadow__)
+    end
+
+    private
+
+    def override_default(interaction, return_value)
+      return unless interaction.any_args?
+      @defaults[interaction.method] = return_value || proc{nil}
+    end
+
+    def add_stub(interaction, return_value_block)
+      @stubs << [interaction, return_value_block] if return_value_block
+    end
+
+    def return_value(interaction)
+      _, return_value = @stubs.reverse.find{|i, v| i == interaction}
+      return_value ||= @defaults[interaction.method]
+      return_value.call
+    end
+  end
+end

data/lib/bogus/verifies_contracts.rb

@@ -7,6 +7,10 @@ class Bogus::VerifiesContracts
     missed = doubled_interactions.for_fake(fake_name).reject do |interaction|
       real_interactions.recorded?(fake_name, interaction)
     end
-    raise Bogus::ContractNotFulfilled.new(fake_name => missed) unless missed.empty?
+
+    unless missed.empty?
+      actual = real_interactions.for_fake(fake_name)
+      raise Bogus::ContractNotFulfilled.new(fake_name, missed: missed, actual: actual)
+    end
   end
 end

data/lib/bogus/verifies_stub_definition.rb

@@ -6,6 +6,7 @@ class Bogus::VerifiesStubDefinition
   def verify!(object, method_name, args)
     stubbing_non_existent_method!(object, method_name) unless object.respond_to?(method_name)
     return unless object.methods.include?(method_name)
+    return if any_args?(args)
     method = object.method(method_name)
     wrong_number_of_arguments!(method, args) if under_number_of_required_arguments?(method, args.size)
     wrong_number_of_arguments!(method, args) if over_number_of_allowed_arguments?(method, args.size)
@@ -35,4 +36,8 @@ class Bogus::VerifiesStubDefinition
 
     args_count > number_of_arguments
   end
+
+  def any_args?(args)
+    [Bogus::AnyArgs] == args
+  end
 end

data/lib/bogus/version.rb

@@ -1,3 +1,3 @@
 module Bogus
-  VERSION = "0.0.2"
+  VERSION = "0.0.3.rc.1"
 end

data/lib/tracks_existence_of_test_doubles.rb

@@ -0,0 +1,11 @@
+module Bogus
+  class TracksExistenceOfTestDoubles
+    def track(object)
+      doubles << object unless doubles.include?(object)
+    end
+
+    def doubles
+      @doubles ||= []
+    end
+  end
+end

data/spec/bogus/adds_recording_spec.rb

@@ -4,30 +4,66 @@ describe Bogus::AddsRecording do
   module SampleModule
     class Library
     end
+
+    class OtherClass
+    end
   end
 
   let(:converts_name_to_class) { stub }
   let(:create_proxy_class) { stub }
   let(:overwrites_classes) { stub }
-  let(:adds_recording) { Bogus::AddsRecording.new(converts_name_to_class, create_proxy_class, overwrites_classes) }
+  let(:overwritten_classes) { stub }
+
+  let(:adds_recording) { isolate(Bogus::AddsRecording) }
 
   before do
     stub(converts_name_to_class).convert { SampleModule::Library }
     stub(create_proxy_class).call { Object }
     stub(overwrites_classes).overwrite
-
-    adds_recording.add(:library)
+    stub(overwritten_classes).add
   end
 
-  it "converts the fake name to class" do
-    converts_name_to_class.should have_received.convert(:library)
-  end
+  context "without class argument" do
+    before do
+      adds_recording.add(:library)
+    end
+
+    it "converts the fake name to class" do
+      converts_name_to_class.should have_received.convert(:library)
+    end
+
+    it "creates the proxy" do
+      create_proxy_class.should have_received.call(:library, SampleModule::Library)
+    end
+
+    it "swaps the classes" do
+      overwrites_classes.should have_received.overwrite('SampleModule::Library', Object)
+    end
 
-  it "creates the proxy" do
-    create_proxy_class.should have_received.call(:library, SampleModule::Library)
+    it "records the overwritten class, so that it can be later restored" do
+      overwritten_classes.should have_received.add("SampleModule::Library", SampleModule::Library)
+    end
   end
 
-  it "swaps the classes" do
-    overwrites_classes.should have_received.overwrite(SampleModule::Library, Object)
+  context "with class argument" do
+    before do
+      adds_recording.add(:library, SampleModule::OtherClass)
+    end
+
+    it "uses the passed class" do
+      converts_name_to_class.should_not have_received.convert(:library)
+    end
+
+    it "creates the proxy" do
+      create_proxy_class.should have_received.call(:library, SampleModule::OtherClass)
+    end
+
+    it "swaps the classes" do
+      overwrites_classes.should have_received.overwrite('SampleModule::OtherClass', Object)
+    end
+
+    it "records the overwritten class, so that it can be later restored" do
+      overwritten_classes.should have_received.add("SampleModule::OtherClass", SampleModule::OtherClass)
+    end
   end
 end

data/spec/bogus/anything_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Bogus::Anything do
+  it "is equal to everything" do
+    anything = Bogus::Anything
+
+    anything.should == "foo"
+    anything.should == "bar"
+    anything.should == 1
+    anything.should == Object.new
+    anything.should == anything
+  end
+end

data/spec/bogus/copies_classes_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../spec_helper'
+require 'spec_helper'
 
 describe Bogus::CopiesClasses do
   module SampleMethods
@@ -57,8 +57,9 @@ describe Bogus::CopiesClasses do
     end
   end
 
-  let(:method_stringifier) { Bogus::MethodStringifier.new }
-  let(:copies_classes) { Bogus::CopiesClasses.new(method_stringifier) }
+  let(:method_stringifier) { isolate(Bogus::MethodStringifier) }
+  let(:makes_substitute_methods) { isolate(Bogus::MakesSubstituteMethods) }
+  let(:copies_classes) { isolate(Bogus::CopiesClasses) }
   let(:fake_class) { copies_classes.copy(klass) }
   let(:fake) { fake_class.new }
 

data/spec/bogus/creates_fakes_with_stubbed_methods_spec.rb

@@ -0,0 +1,121 @@
+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(stub_all: :stubbed_object) }
+
+    let(:creates_anonymous_stubs) { isolate(CreatesFakesWithStubbedMethods) }
+
+    before do
+      stub(fake_configuration).include? { false }
+    end
+
+    context "given symbol as first parameter" do
+      let(:fake) { [:foo, {as: :class}, "something"] }
+
+      before do
+        creates_anonymous_stubs.create(:foo, bar: 1, as: :class) { "something" }
+      end
+
+      it "creates fakes" do
+        creates_fakes.should have_created(:foo, {as: :class}, "something")
+      end
+
+      it "stubs all the given methods" do
+        multi_stubber.should have_received.stub_all(fake, bar: 1)
+      end
+    end
+
+    context "given hash as first parameter" do
+      before do
+        creates_anonymous_stubs.create(bar: 1)
+      end
+
+      it "does not create fakes" do
+        creates_fakes.fakes.should == []
+      end
+
+      it "stubs all the given methods" do
+        multi_stubber.should have_received.stub_all(responds_to_everything, bar: 1)
+      end
+    end
+
+    context "given symbol as only parameter" do
+      let(:fake) { [:foo, {}, "something"] }
+
+      before do
+        creates_anonymous_stubs.create(:foo) { "something" }
+      end
+
+      it "creates fakes" do
+        creates_fakes.should have_created(:foo, {}, "something")
+      end
+
+      it "stubs all the given methods" do
+        multi_stubber.should have_received.stub_all(fake)
+      end
+    end
+
+    context "with no parameters" do
+      before do
+        creates_anonymous_stubs.create
+      end
+
+      it "does not create fakes" do
+        creates_fakes.fakes.should == []
+      end
+
+      it "stubs all the given methods" do
+        multi_stubber.should have_received.stub_all(responds_to_everything)
+      end
+    end
+
+    context "when the fake was globally configured" do
+      let(:fake) { [:foo, {as: :class}, "SomeClass"] }
+
+      before do
+        stub(fake_configuration).include?(:foo) { true }
+        stub(fake_configuration).get(:foo) { FakeDefinition.new(opts: {as: :class},
+                                                                stubs: {xyz: "abc"},
+                                                                class_block: proc{"SomeClass"}) }
+
+        creates_anonymous_stubs.create(:foo)
+      end
+
+      it "uses the configuration to create fake" do
+        creates_fakes.fakes.should == [fake]
+
+        fake_configuration.should have_received.include?(:foo)
+        fake_configuration.should have_received.get(:foo)
+      end
+
+      it "stubs the methods defined in configuration" do
+        multi_stubber.should have_received.stub_all(fake, xyz: "abc")
+      end
+    end
+
+    context "overriding the global configuration" do
+      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"}) }
+
+        creates_anonymous_stubs.create(:foo, as: :instance, b: "d", c: "e") { "SomeOtherClass" }
+      end
+
+      it "overrides the class block and fake options" do
+        creates_fakes.should have_created(:foo, {as: :instance}, "SomeOtherClass")
+      end
+
+      it "overrides the stubbed methods" do
+        multi_stubber.should have_received.stub_all(fake, a: "b", b: "d", c: "e")
+      end
+    end
+  end
+end

data/spec/bogus/double_spec.rb

@@ -1,31 +1,74 @@
 require 'spec_helper'
 
-describe Bogus::Double do
-  let(:rr_double) { stub }
-  let(:verifies_stub_definition) { stub }
-  let(:records_double_interactions) { stub }
+module Bogus
+  describe Double do
+    shared_examples_for "double behavior" do
+      it "tracks existence of test doubles" do
+        mock(double_tracker).track(object)
 
-  let(:object) { "strings have plenty of methods to call" }
+        double.stub.foo("a", "b") { "the result" }
+      end
 
-  let(:bogus_double) { isolate(Bogus::Double, double: rr_double) }
+      it "verifies stub definition" do
+        mock(verifies_stub_definition).verify!(object, :foo, ["a", "b"])
 
-  before do
-    stub(verifies_stub_definition).verify!
-    stub(records_double_interactions).record
-    stub(rr_double).method_name
+        double.stub.foo("a", "b") { "the result" }
+      end
 
-    bogus_double.method_name(:foo, :bar)
-  end
+      it "stubs shadow methods" do
+        object.extend RecordInteractions
+        mock(object.__shadow__).stubs(:foo, "a", "b")
 
-  it "verifies that stub definition matches the real definition" do
-    verifies_stub_definition.should have_received.verify!(object, :method_name, [:foo, :bar])
-  end
+        double.stub.foo("a", "b") { "the result" }
+      end
 
-  it "records the stub interaction so that it can be verified later" do
-    records_double_interactions.should have_received.record(object, :method_name, [:foo, :bar])
-  end
+      it "mocks shadow methods" do
+        object.extend RecordInteractions
+        mock(object.__shadow__).mocks(:foo, "a", "b")
+
+        double.mock.foo("a", "b") { "the result" }
+      end
+
+      it "adds method overwriting" do
+        double.stub.foo("a", "b") { "the result" }
+
+        overwrites_methods.overwrites.should == [[object, :foo]]
+      end
+
+      it "records double interactions" do
+        mock(records_double_interactions).record(object, :foo, ["a", "b"])
+
+        double.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(:overwrites_methods) { FakeMethodOverwriter.new }
+    let(:double) { isolate(Double) }
+
+    context "with regular objects" do
+      let(:object) { Samples::Foo.new }
+
+      include_examples "double behavior"
+    end
+
+    context "with fakes" do
+      let(:object) { Samples::FooFake.new }
+
+      include_examples "double behavior"
+    end
+
+    class FakeMethodOverwriter
+      def overwrite(object, method)
+        overwrites << [object, method]
+        object.extend RecordInteractions
+      end
 
-  it "proxies the method call" do
-    rr_double.should have_received.method_name(:foo, :bar)
+      def overwrites
+        @overwrites ||= []
+      end
+    end
   end
 end