bogus 0.0.2 → 0.0.3.rc.1

data/spec/bogus/multi_stubber_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Bogus::MultiStubber do
+  let(:double) { FakeDouble.new }
+  let(:create_double) { proc{ double } }
+  let(:any_args) { Bogus::AnyArgs }
+
+  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)
+
+    double.stubbed.should == [[:foo, [any_args], 1], [:bar, [any_args], 2]]
+  end
+
+  it "uses passed procs as the return value block" do
+    multi_stubber.stub_all(Object.new, foo: proc{ 1 })
+
+    double.stubbed.should == [[:foo, [any_args], 1]]
+  end
+
+  class FakeDouble
+    def stubbed
+      @stubbed ||= []
+    end
+
+    def stubs(name, *args, &return_value)
+      stubbed << [name, args, return_value.call]
+    end
+  end
+end

data/spec/bogus/overwriten_classes_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Bogus::OverwrittenClasses do
+  let(:overwritten_classes) { Bogus::OverwrittenClasses.new }
+
+  let(:klass) { Class.new }
+
+  it "adds classes" do
+    overwritten_classes.add("Foo::Bar", klass)
+    overwritten_classes.add("Baz::Bam", klass)
+
+    overwritten_classes.classes.should == [["Foo::Bar", klass],
+                                           ["Baz::Bam", klass]]
+  end
+
+  it "clears overwritten classes" do
+    overwritten_classes.add("Foo::Bar", klass)
+    overwritten_classes.add("Baz::Bam", klass)
+    overwritten_classes.clear
+
+    overwritten_classes.classes.should == []
+  end
+
+  it "returns an empty array with no classes" do
+    overwritten_classes.classes.should == []
+  end
+end

data/spec/bogus/overwrites_classes_spec.rb

@@ -12,13 +12,13 @@ describe Bogus::OverwritesClasses do
   let(:overwrites_classes) { Bogus::OverwritesClasses.new }
 
   it "overwrites nested classes" do
-    overwrites_classes.overwrite(SampleOuterModule::SampleModule::SampleClass, new_class)
+    overwrites_classes.overwrite('SampleOuterModule::SampleModule::SampleClass', new_class)
 
     SampleOuterModule::SampleModule::SampleClass.should equal(new_class)
   end
 
   it "overwrites top level classes" do
-    overwrites_classes.overwrite(SampleOuterModule, new_class)
+    overwrites_classes.overwrite('SampleOuterModule', new_class)
 
     SampleOuterModule.should equal(new_class)
   end

data/spec/bogus/overwrites_methods_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+module Bogus
+  describe OverwritesMethods do
+    let(:method_stringifier) { MethodStringifier.new }
+    let(:makes_substitute_methods) { isolate(MakesSubstituteMethods) }
+    let(:overwriter) { isolate(OverwritesMethods) }
+
+    let(:object) { SampleOfOverwriting.new }
+
+    context "with regular objects" do
+      class SampleOfOverwriting
+        def greet(name)
+          "Hello #{name}"
+        end
+
+        def wave(part_of_body = "hand", speed = "slowly")
+          "I'm waving my #{part_of_body} #{speed}"
+        end
+      end
+
+      before do
+        overwriter.overwrite(object, :greet)
+      end
+
+      it "does not change the method signature" do
+        object.greet("John").should == object
+      end
+
+      it "does not change the method signature" do
+        expect {
+          object.greet("John", "Paul")
+        }.to raise_error(ArgumentError)
+      end
+
+      it "adds interaction recording to the overwritten object" do
+        object.greet("John")
+
+        object.should Bogus.have_received.greet("John")
+        object.should_not Bogus.have_received.greet("Paul")
+      end
+
+      it "can reset the overwritten methods" do
+        overwriter.reset(object)
+
+        object.greet("John").should == "Hello John"
+      end
+
+      it "is imdepotent when overwriting" do
+        overwriter.overwrite(object, :greet)
+        overwriter.overwrite(object, :greet)
+        overwriter.overwrite(object, :greet)
+
+        overwriter.reset(object)
+
+        object.greet("John").should == "Hello John"
+      end
+    end
+
+    context "with objects that use method missing" do
+      class UsesMethodMissing
+        def respond_to?(name)
+          name == :greet
+        end
+
+        def method_missing(name, *args, &block)
+          "the original return value"
+        end
+      end
+
+      let(:object) { UsesMethodMissing.new }
+
+      before do
+        overwriter.overwrite(object, :greet)
+      end
+
+      it "can overwrite the non-existent methods" do
+        object.greet.should equal(object)
+      end
+
+      it "can be reset back to the original state" do
+        overwriter.overwrite(object, :greet)
+        overwriter.overwrite(object, :greet)
+
+        overwriter.reset(object)
+
+        object.greet.should == "the original return value"
+      end
+    end
+
+    context "with fakes" do
+      let(:fake) { Samples::FooFake.new }
+
+      it "does nothing because fakes methods already work as we need" do
+        overwriter.overwrite(fake, :foo_bar)
+
+        fake.should_not respond_to(:foo_bar)
+      end
+
+      it "does not reset fakes, because there is nothing to reset" do
+        expect {
+          overwriter.reset(fake)
+        }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/bogus/proxy_class_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe Bogus::ProxyClass do
   module SampleModule
     class GrandLibrary
+      SAMPLE_CONSTANT = "foo"
+
       def checkout(book, user)
         :checkouted
       end
@@ -69,6 +71,10 @@ describe Bogus::ProxyClass do
     }.to raise_error(StandardError)
   end
 
+  it "allows accessing the constants defined on proxied class" do
+    proxy_class::SAMPLE_CONSTANT.should == "foo"
+  end
+
   class FakeRepository
     def initialize
       @recordings = []

data/spec/bogus/record_interactions_spec.rb

@@ -7,21 +7,20 @@ describe Bogus::RecordInteractions do
   end
 
   let(:sample) { SampleRecordsInteractions.new }
-  let!(:rr) { Bogus::RRProxy }
 
   it "allows verifying that interactions happened" do
     sample.__record__(:foo, 1, 2, 3)
 
-    sample.__inner_object__.should have_received.foo(1, 2, 3)
+    sample.__shadow__.has_received(:foo, [1,2,3]).should be_true
   end
 
   it "allows verifying that interactions didn't happen" do
     sample.__record__(:bar)
 
-    sample.__inner_object__.should_not have_received.foo
+    sample.__shadow__.has_received(:foo, [1,2,3]).should be_false
   end
 
-  it "returns self from record" do
+  it "returns self from record by default" do
     sample.__record__(:foo).should == sample
   end
 end

data/spec/bogus/registers_created_fakes_spec.rb

@@ -3,12 +3,14 @@ require 'spec_helper'
 describe Bogus::RegistersCreatedFakes do
   let(:fake_registry) { stub }
   let(:creates_fakes) { stub }
+  let(:double_tracker) { stub }
 
   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)
   end
 
   it "registers the fakes created by creates_fakes" do
@@ -17,6 +19,12 @@ describe Bogus::RegistersCreatedFakes do
     fake_registry.should have_received.store(:foo, :the_fake)
   end
 
+  it "tracks the created fakes for purposes of mock expectations" do
+    registers_created_fakes.create(:foo, as: :instance) { Object }
+
+    double_tracker.should have_received.track(:the_fake)
+  end
+
   it "returns the created fake" do
     fake = registers_created_fakes.create(:foo, as: :instance) { Object }
 

data/spec/bogus/resets_overwritten_classes_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Bogus::ResetsOverwrittenClasses do
+  let(:classes) { [['Foo', :foo], ['Bar', :bar]] }
+  let(:overwritten_classes) { stub }
+  let(:overwrites_classes) { stub }
+
+  let(:resets_overwritten_classes) { isolate(Bogus::ResetsOverwrittenClasses) }
+
+  before do
+    stub(overwritten_classes).classes { classes }
+    stub(overwritten_classes).clear
+    stub(overwrites_classes).overwrite
+
+    resets_overwritten_classes.reset
+  end
+
+  it "overwrites back all of the overwritten classes" do
+    overwrites_classes.should have_received.overwrite('Foo', :foo)
+    overwrites_classes.should have_received.overwrite('Bar', :bar)
+  end
+
+  it "clears the overwritten classes" do
+    overwritten_classes.should have_received.clear
+  end
+end

data/spec/bogus/resets_stubbed_methods_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Bogus::ResetsStubbedMethods do
+  let(:double_tracker) { stub }
+  let(:overwrites_methods) { stub }
+
+  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)
+
+    resets_stubbed_methods.reset_all_doubles
+  end
+end

data/spec/bogus/shadow_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Bogus::Shadow do
+  let(:object) { Samples::FooFake.new }
+  let(:shadow) { Bogus::Shadow.new{ object } }
+
+  shared_examples_for "spying on shadows" do
+    context "spying" do
+      before do
+        shadow.run(:foo, "a", "b") rescue nil # for when the method raises an error
+      end
+
+      it "returns the called methods" do
+        shadow.has_received(:foo, ["a", "b"]).should be_true
+      end
+
+      it "does not return true for interactions that did not happen" do
+        shadow.has_received(:foo, ["a", "c"]).should be_false
+        shadow.has_received(:bar, ["a", "c"]).should be_false
+      end
+    end
+  end
+
+  context "unrecorded interactions" do
+    it "returns the object, so that calls can be chained" do
+      shadow.run(:foo, "a", "b").should == object
+    end
+
+    include_examples "spying on shadows"
+  end
+
+  context "interactions that raise exceptions" do
+    class SomeWeirdException < StandardError; end
+
+    before do
+      shadow.stubs(:foo, "a", "b") { raise SomeWeirdException, "failed!" }
+    end
+
+    it "raises the error when called" do
+      expect {
+        shadow.run(:foo, "a", "b")
+      }.to raise_error(SomeWeirdException, "failed!")
+    end
+
+    include_examples "spying on shadows"
+  end
+
+  context "interactions with no return value" do
+    before do
+      shadow.stubs(:foo, ["a", "b"])
+    end
+
+    it "returns the object" do
+      shadow.run(:foo, ["a", "b"]).should == object
+    end
+
+    include_examples "spying on shadows"
+  end
+
+  context "interactions with AnyArgs" do
+    before do
+      shadow.stubs(:foo, "a", "b") { "old specific value" }
+      shadow.stubs(:foo, Bogus::AnyArgs) { "default value" }
+      shadow.stubs(:foo, "a", "d") { "new specific value" }
+    end
+
+    it "changes the default value returned from method" do
+      shadow.run(:foo, "b", "c").should == "default value"
+    end
+
+    it "overwrites the old specific stubbed values" do
+      shadow.run(:foo, "a", "b").should == "default value"
+    end
+
+    it "does not affect the new specific stubbed values" do
+      shadow.run(:foo, "a", "d").should == "new specific value"
+    end
+
+    it "allows spying on calls using any args" do
+      shadow.run(:foo, "a", "c")
+
+      shadow.has_received(:foo, [Bogus::AnyArgs]).should be_true
+    end
+  end
+
+  context "interactions that take anything" do
+    before do
+      shadow.stubs(:foo, "a", Bogus::Anything) { "return value" }
+    end
+
+    it "changes the return value for calls that match" do
+      shadow.run(:foo, "a", "c").should == "return value"
+    end
+
+    it "does not affect the return value for other calls" do
+      shadow.stubs(:foo, "a", "b") { "specific value" }
+
+      shadow.run(:foo, "a", "b").should == "specific value"
+    end
+
+    it "allows spying on calls using anything in args" do
+      shadow.run(:foo, "a", "b")
+
+      shadow.has_received(:foo, [Bogus::Anything, "b"]).should be_true
+    end
+  end
+
+  context "stubbed interactions" do
+    before do
+      shadow.stubs(:foo, "a", "b") { "stubbed value" }
+    end
+
+    it "returns the stubbed value" do
+      shadow.run(:foo, "a", "b").should == "stubbed value"
+    end
+
+    it "returns the latest stubbed value" do
+      shadow.stubs(:foo, "a", "b") { "stubbed twice" }
+      shadow.stubs(:foo, "b", "c") { "different params" }
+
+      shadow.run(:foo, "a", "b").should == "stubbed twice"
+      shadow.run(:foo, "b", "c").should == "different params"
+    end
+
+    it "returns the default value for non-stubbed calls" do
+      shadow.run(:foo, "c", "d").should == object
+      shadow.run(:bar).should == object
+    end
+
+    it "does not contribute towards unsatisfied interactions" do
+      shadow.unsatisfied_interactions.should be_empty
+    end
+
+    it "adds required interaction when mocking over stubbing" do
+      shadow.mocks(:foo, "a", "b") { "stubbed value" }
+
+      shadow.unsatisfied_interactions.should_not be_empty
+    end
+
+    include_examples "spying on shadows"
+  end
+
+  context "mocked interactions" do
+    before do
+      shadow.mocks(:foo, "a", "b") { "mocked value" }
+    end
+
+    it "returns the mocked value" do
+      shadow.run(:foo, "a", "b").should == "mocked value"
+    end
+
+    it "overwrites the stubbed value" do
+      shadow.stubs(:foo, "a", "c") { "stubbed value" }
+      shadow.mocks(:foo, "a", "c") { "mocked value" }
+
+      shadow.run(:foo, "a", "c").should == "mocked value"
+    end
+
+    it "is overwritten by stubbing" do
+      shadow.mocks(:foo, "a", "c") { "mocked value" }
+      shadow.stubs(:foo, "a", "c") { "stubbed value" }
+
+      shadow.run(:foo, "a", "c").should == "stubbed value"
+    end
+
+    it "removes the required interaction when stubbing over mocking" do
+      shadow.stubs(:foo, "a", "b") { "stubbed value" }
+
+      shadow.unsatisfied_interactions.should be_empty
+    end
+
+    it "returns the default value for non-stubbed calls" do
+      shadow.run(:foo, "a", "c").should == object
+    end
+
+    it "contributes towards unsatisfied interactions" do
+      shadow.unsatisfied_interactions.should  =~ [Bogus::Interaction.new(:foo, ["a", "b"])]
+    end
+
+    include_examples "spying on shadows"
+  end
+end