bogus 0.0.2 → 0.0.3.rc.1

data/spec/bogus/ensures_all_interactions_satisfied_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Bogus::EnsuresAllInteractionsSatisfied do
+  let(:ensures_all_interactions_satisfied) { isolate(Bogus::EnsuresAllInteractionsSatisfied) }
+
+  it "does nothing with all interactions satisfied" do
+    objects = 3.times.map { |n| Samples::FooFake.new }
+
+    expect {
+      ensures_all_interactions_satisfied.ensure_satisfied!(objects)
+    }.not_to raise_error
+  end
+
+  it "raises an error enumerating satisfied and unsatisfied interactions" do
+    foo = Samples::FooFake.new
+    foo.__shadow__.mocks(:foo, "a", "b") { "result" }
+    foo.__shadow__.mocks(:foo, "a", "c") { "result 2" }
+    foo.__shadow__.run(:foo, "a", "b")
+
+    bar = Samples::FooFake.new
+    bar.__shadow__.stubs(:foo, "a", "b") { "result" }
+    bar.__shadow__.stubs(:foo, "a", "c") { "result 2" }
+    bar.__shadow__.run(:foo, "a", "b")
+    bar.__shadow__.run(:foo, "x", "y")
+
+    msg = <<-EOF
+    Some of the mocked interactions were not satisfied:
+
+      - #{foo.inspect}.foo("a", "c")
+
+    The following calls were recorded:
+
+      - #{foo.inspect}.foo("a", "b")
+      - #{bar.inspect}.foo("a", "b")
+      - #{bar.inspect}.foo("x", "y")
+    EOF
+
+    expect {
+      ensures_all_interactions_satisfied.ensure_satisfied!([foo, bar])
+    }.to raise_error(Bogus::NotAllExpectationsSatisfied, msg.gsub(/ {4}/, ''))
+  end
+
+end

data/spec/bogus/fake_configuration_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Bogus::FakeConfiguration do
+  let(:config) { Bogus::FakeConfiguration.new }
+
+  it "does not contain not configured fakes" do
+    config.include?(:foo).should be_false
+  end
+
+  def class_block(name)
+    config.get(name).class_block
+  end
+
+  def opts(name)
+    config.get(name).opts
+  end
+
+  def stubs(name)
+    config.get(name).stubs
+  end
+
+  it "contains configured fakes" do
+    config.evaluate do
+      fake(:foo, as: :class, class: proc{Samples::Foo}) do
+        bar "the bar"
+      end
+    end
+
+    config.include?(:foo).should be_true
+    config.include?(:bar).should be_false
+  end
+
+  it "returns the configuration for a fake" do
+    config.evaluate do
+      fake(:foo, as: :class, class: proc{Samples::Foo}) do
+        bar "the bar"
+      end
+    end
+
+    opts(:foo).should == {as: :class}
+    stubs(:foo).should == {bar: "the bar"}
+    class_block(:foo).call.should == Samples::Foo
+  end
+
+  context "with no class" do
+    it "does not return any class block" do
+      config.evaluate do
+        fake(:foo, as: :class) { bar "bar" }
+      end
+
+      opts(:foo).should == {as: :class}
+      stubs(:foo).should == {bar: "bar"}
+      class_block(:foo).should be_nil
+    end
+  end
+
+  context "with no options" do
+    it "does not return any options" do
+      config.evaluate do
+        fake(:foo) { bar "bar" }
+      end
+
+      opts(:foo).should == {}
+      stubs(:foo).should == {bar: "bar"}
+      class_block(:foo).should be_nil
+    end
+  end
+
+  context "with block return value definitions" do
+    it "returns the values, not blocks" do
+      config.evaluate do
+        fake(:foo) { bar {"bar"} }
+      end
+
+      stubs(:foo)[:bar].call.should == "bar"
+    end
+
+    it "does not evaluate the blocks when getting, nor when setting" do
+      config.evaluate do
+        fake(:foo) { bar { raise "gotcha" } }
+      end
+
+      block = stubs(:foo)[:bar]
+      expect{ block.call }.to raise_error
+    end
+  end
+
+  context "witn no stubs block" do
+    it "returns the options" do
+      config.evaluate do
+        fake(:foo, as: :class)
+      end
+
+      opts(:foo).should == {as: :class}
+      stubs(:foo).should == {}
+      class_block(:foo).should be_nil
+    end
+  end
+end

data/spec/bogus/fakes_classes_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Bogus::FakesClasses do
+  let(:creates_fakes_with_stubbed_methods) { FakeCreatorOfFakes.new }
+  let(:overwrites_classes) { stub }
+  let(:overwritten_classes) { stub }
+
+  let(:fakes_classes) { isolate(Bogus::FakesClasses) }
+
+  module Samples
+    class WillBeOverwritten
+    end
+  end
+
+  before do
+    stub(overwrites_classes).overwrite
+    stub(overwritten_classes).add
+  end
+
+  it "creates a fake named after the class" do
+    fakes_classes.fake(Samples::WillBeOverwritten, foo: "bar")
+
+    creates_fakes_with_stubbed_methods.should have_created(:will_be_overwritten,
+                                                           {as: :class, foo: "bar"}, Samples::WillBeOverwritten)
+  end
+
+  it "overwrites the class with the fake" do
+    fake = [:will_be_overwritten, {as: :class}, Samples::WillBeOverwritten]
+
+    fakes_classes.fake(Samples::WillBeOverwritten)
+
+    overwrites_classes.should have_received.overwrite("Samples::WillBeOverwritten", fake)
+  end
+
+  it "stores the overwritten class so that it can be replaced back later" do
+    fakes_classes.fake(Samples::WillBeOverwritten)
+
+    overwritten_classes.should have_received.add("Samples::WillBeOverwritten", Samples::WillBeOverwritten)
+  end
+
+  it "uses the passed fake name if provided" do
+    fakes_classes.fake(Samples::WillBeOverwritten, fake_name: :foo_bar)
+
+    creates_fakes_with_stubbed_methods.should have_created(:foo_bar, {as: :class}, Samples::WillBeOverwritten)
+  end
+end

data/spec/bogus/have_received_matcher_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Bogus::HaveReceivedMatcher do
+  let(:verifies_stub_definition) { stub(verify!: nil) }
+  let(:records_double_interactions) { stub(record: nil) }
+  let(:have_received_matcher) { isolate(Bogus::HaveReceivedMatcher) }
+  let(:have_received) { have_received_matcher.method_call }
+  let(:fake) { Samples::FooFake.new }
+
+  before do
+    fake.foo("a", "b")
+  end
+
+  it "matches when the spy has received the message" do
+    fake.should have_received.foo("a", "b")
+  end
+
+  it "does not match if the spy hasn't received the message" do
+    fake.should_not 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"])
+
+    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"])
+
+    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
+
+    have_received_matcher.matches?("foo").should be_false
+    have_received_matcher.failure_message_for_should.should == Bogus::HaveReceivedMatcher::NO_SHADOW
+    have_received_matcher.failure_message_for_should_not.should == Bogus::HaveReceivedMatcher::NO_SHADOW
+  end
+
+  it "returns a readable error message for fakes" do
+    have_received.foo("a", "c")
+
+    have_received_matcher.matches?(fake)
+
+    have_received_matcher.failure_message_for_should.should ==
+      %Q{Expected #{fake.inspect} to have received foo("a", "c"), but it didn't.\n\n}+
+        %Q{The recorded interactions were:\n} +
+        %Q{  - foo("a", "b")\n}
+  end
+end

data/spec/bogus/interaction_spec.rb

@@ -7,13 +7,24 @@ describe Bogus::Interaction do
     [[:foo, [:bar], "value"], [:foo, [:bar], "value"]],
     [[:foo, [:bar]], [:foo, [:bar], "value"]],
     [[:foo, [:bar], "value"], [:foo, [:bar]]],
-    [[:foo, [:bar]], [:foo, [:bar]]]
+    [[:foo, [:bar]], [:foo, [:bar]]],
+    [[:foo, [Bogus::AnyArgs]], [:foo, [:bar]]],
+    [[:foo, [:bar]], [:foo, [Bogus::AnyArgs]]],
+    [[:foo, [Bogus::AnyArgs], "same value"], [:foo, [:bar], "same value"]],
+    [[:foo, [:bar], "same value"], [:foo, [Bogus::AnyArgs], "same value"]],
+    [[:foo, [:bar, Bogus::Anything]], [:foo, [:bar, :baz]]],
+    [[:foo, [:bar, :baz]], [:foo, [:bar, Bogus::Anything]]],
+    [[:foo, [:bar, Bogus::Anything]], [:foo, [Bogus::Anything, :baz]]]
   ]
 
   different = [
     [[:foo, [:bar], "value"], [:foo, [:bar], "value2"]],
     [[:foo, [:bar], "value"], [:baz, [:bar], "value"]],
     [[:foo, [:baz], "value"], [:foo, [:bar], "value"]],
+    [[:foo, [Bogus::AnyArgs]], [:bar, [:bar]]],
+    [[:foo, [:bar]], [:bar, [Bogus::AnyArgs]]],
+    [[:foo, [Bogus::AnyArgs], "some value"], [:foo, [:bar], "other value"]],
+    [[:foo, [:bar], "some value"], [:foo, [Bogus::AnyArgs], "other value"]],
     [[:foo, [:bar]], [:foo, [:baz]]],
     [[:baz, [:bar]], [:foo, [:bar]]]
   ]
@@ -46,22 +57,22 @@ describe Bogus::Interaction do
   end
 
   it "differs exceptions from empty return values" do
-    first = Bogus::Interaction.new(:foo, :bar) { raise SomeError }
-    second = Bogus::Interaction.new(:foo, :bar) { nil }
+    first = Bogus::Interaction.new(:foo, [:bar]) { raise SomeError }
+    second = Bogus::Interaction.new(:foo, [:bar]) { nil }
 
     first.should_not == second
   end
 
   it "differs raised exceptions from ones just returned from the block" do
-    first = Bogus::Interaction.new(:foo, :bar) { raise SomeError }
-    second = Bogus::Interaction.new(:foo, :bar) { SomeError }
+    first = Bogus::Interaction.new(:foo, [:bar]) { raise SomeError }
+    second = Bogus::Interaction.new(:foo, [:bar]) { SomeError }
 
     first.should_not == second
   end
 
   it "considers exceptions of the same type as equal" do
-    first = Bogus::Interaction.new(:foo, :bar) { raise SomeError }
-    second = Bogus::Interaction.new(:foo, :bar) { raise SomeError }
+    first = Bogus::Interaction.new(:foo, [:bar]) { raise SomeError }
+    second = Bogus::Interaction.new(:foo, [:bar]) { raise SomeError }
 
     first.should == second
   end

data/spec/bogus/interactions_repository_spec.rb

@@ -47,4 +47,46 @@ describe Bogus::InteractionsRepository do
 
     interactions_repository.for_fake(:foo).should == [Bogus::Interaction.new(:bar, [1, 2])]
   end
+
+  it "ignores arguments if the recorded interaction was recorded with any_args" do
+    interactions_repository.record(:foo, :bar, Bogus::AnyArgs)
+
+    recorded?(:foo, :bar, 1).should be_true
+  end
+
+  it "ignores arguments if the checked interaction has any_args" do
+    interactions_repository.record(:foo, :bar, 1)
+
+    recorded?(:foo, :bar, Bogus::AnyArgs).should be_true
+  end
+
+  it "takes method name into account when matching interaction with wildcard arguments" do
+    interactions_repository.record(:foo, :baz, 1)
+
+    recorded?(:foo, :bar, Bogus::AnyArgs).should be_false
+  end
+
+  it "ignores arguments if the recorded interaction was recorded with wildcard argument" do
+    interactions_repository.record(:foo, :bar, 1, Bogus::Anything)
+
+    recorded?(:foo, :bar, 1, 2).should be_true
+  end
+
+  it "takes other arguments into account when matching interactions with wildcards" do
+    interactions_repository.record(:foo, :bar, 1, Bogus::Anything)
+
+    recorded?(:foo, :bar, 2, 1).should be_false
+  end
+
+  it "ignores arguments if the checked interaction has any_args" do
+    interactions_repository.record(:foo, :bar, 1, 2)
+
+    recorded?(:foo, :bar, 1, Bogus::Anything).should be_true
+  end
+
+  it "takes method name into account when matching interaction with wildcard arguments" do
+    interactions_repository.record(:foo, :baz, 1, 2)
+
+    recorded?(:foo, :bar, 1, Bogus::Anything).should be_false
+  end
 end

data/spec/bogus/makes_substitute_methods_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Bogus
+  describe MakesSubstituteMethods do
+    class SampleForCopyingMethods
+      def self.foo(name, value = "hello", *rest, &block)
+        "this is the method body"
+      end
+    end
+
+    let(:method_stringifier) { isolate(MethodStringifier) }
+    let(:makes_substitute_methods) { isolate(MakesSubstituteMethods) }
+
+    it "makes a copy of the method with its params and adds recording" do
+      copy = makes_substitute_methods.stringify(SampleForCopyingMethods.method(:foo))
+
+      copy.should == <<-EOF
+      def foo(name, value = {}, *rest, &block)
+        __record__(:foo, name, value, *rest, &block)
+      end
+      EOF
+    end
+  end
+end

data/spec/bogus/mocking_dsl_spec.rb

@@ -4,27 +4,64 @@ describe Bogus::MockingDSL do
   class ExampleFoo
     def foo(bar)
     end
+
+    def hello(greeting, name)
+    end
+
+    def self.bar(baz)
+      "Hello #{baz}"
+    end
   end
 
   class Stubber
     extend Bogus::MockingDSL
   end
 
+  before do
+    Bogus.send(:clear_expectations)
+  end
+
   describe "#stub" do
-    it "allows stubbing the existing methods" do
-      baz = ExampleFoo.new
+    let(:baz) { ExampleFoo.new }
 
+    it "allows stubbing the existing methods" do
       Stubber.stub(baz).foo("bar") { :return_value }
 
       baz.foo("bar").should == :return_value
     end
 
+    it "can stub method with any parameters" do
+      Stubber.stub(baz).foo(Stubber.any_args) { :default_value }
+      Stubber.stub(baz).foo("bar") { :foo_value }
+
+      baz.foo("a").should == :default_value
+      baz.foo("b").should == :default_value
+      baz.foo("bar").should == :foo_value
+    end
+
+    it "can stub method with some wildcard parameters" do
+      Stubber.stub(baz).hello(Stubber.any_args) { :default_value }
+      Stubber.stub(baz).hello("welcome", Stubber.anything) { :greeting_value }
+
+      baz.hello("hello", "adam").should == :default_value
+      baz.hello("welcome", "adam").should == :greeting_value
+      baz.hello("welcome", "rudy").should == :greeting_value
+    end
+
     it "does not allow stubbing non-existent methods" do
       baz = ExampleFoo.new
       expect do
         Stubber.stub(baz).does_not_exist("bar") { :return_value }
       end.to raise_error(NameError)
     end
+
+    it "unstubs methods after each test" do
+      Stubber.stub(ExampleFoo).bar("John") { "something else" }
+
+      Bogus.after_each_test
+
+      ExampleFoo.bar("John").should == "Hello John"
+    end
   end
 
   describe "#have_received" do
@@ -52,12 +89,42 @@ describe Bogus::MockingDSL do
 
     it "can be used with plain old Ruby objects" do
       object = ExampleFoo.new
-      stub(object).foo
+      Stubber.stub(object).foo(Stubber.any_args)
 
       object.foo('test')
 
       object.should Stubber.have_received.foo("test")
     end
+
+    class ClassWithMatches
+      def matches?(something)
+      end
+    end
+
+    it "can be used with objects that have same methods as an RSpec expectation" do
+      fake = Bogus.fake_for(:class_with_matches)
+
+      fake.matches?("foo")
+
+      fake.should Bogus.have_received.matches?("foo")
+    end
+
+    class PassesSelfToCollaborator
+      def hello(example)
+        example.foo(self)
+      end
+    end
+
+    it "can be used with self references" do
+      Bogus.record_calls_for(:passes_self_to_collaborator)
+
+      fake = Bogus.fake_for(:example_foo)
+      object = PassesSelfToCollaborator.new
+
+      object.hello(fake)
+
+      fake.should Bogus.have_received.foo(object)
+    end
   end
 
   class Mocker
@@ -65,12 +132,49 @@ describe Bogus::MockingDSL do
   end
 
   describe "#mock" do
-    it "allows mocking the existing methods" do
-      baz = ExampleFoo.new
+    let(:object) { ExampleFoo.new }
+    let(:fake) { Bogus.fake_for(:example_foo) { ExampleFoo } }
 
-      Mocker.mock(baz).foo("bar") { :return_value }
+    shared_examples_for "mocking dsl" do
+      before do
+        Mocker.mock(baz).foo("bar") { :return_value }
+      end
 
-      baz.foo("bar").should == :return_value
+      it "allows mocking the existing methods" do
+        baz.foo("bar").should == :return_value
+      end
+
+      it "verifies that the methods mocked exist" do
+        expect {
+          Mocker.mock(baz).does_not_exist { "whatever" }
+        }.to raise_error(NameError)
+      end
+
+      it "raises errors when mocks were not called" do
+        expect {
+          Bogus.after_each_test
+        }.to raise_error(Bogus::NotAllExpectationsSatisfied)
+      end
+
+      it "clears the data between tests" do
+        Bogus.send(:clear_expectations)
+
+        expect {
+          Bogus.after_each_test
+        }.not_to raise_error(Bogus::NotAllExpectationsSatisfied)
+      end
+    end
+
+    context "with fakes" do
+      it_behaves_like "mocking dsl" do
+        let(:baz) { fake }
+      end
+    end
+
+    context "with regular objects" do
+      it_behaves_like "mocking dsl" do
+        let(:baz) { object }
+      end
     end
   end
 
@@ -113,4 +217,127 @@ describe Bogus::MockingDSL do
       greeter.baz.foo.should == "bar"
     end
   end
+
+  class SampleOfConfiguredFake
+    def self.foo(x)
+    end
+
+    def self.bar(x, y)
+    end
+
+    def self.baz
+    end
+  end
+
+  describe "globally configured fakes" do
+    before do
+      Bogus.fakes do
+        fake(:globally_configured_fake, as: :class, class: proc{SampleOfConfiguredFake}) do
+          foo "foo"
+          bar { "bar" }
+          baz { raise "oh noes!" }
+        end
+      end
+    end
+
+    it "returns configured fakes" do
+      the_fake = Stubber.fake(:globally_configured_fake)
+
+      the_fake.foo('a').should == "foo"
+      the_fake.bar('a', 'b').should == "bar"
+    end
+
+    it "allows overwriting stubbed methods" do
+      the_fake = Stubber.fake(:globally_configured_fake, bar: "baz")
+
+      the_fake.foo('a').should == "foo"
+      the_fake.bar('a', 'b').should == "baz"
+    end
+
+    it "evaluates the block passed to method in configuration when method is called" do
+      the_fake = Stubber.fake(:globally_configured_fake)
+
+      expect{ the_fake.baz }.to raise_error("oh noes!")
+    end
+  end
+
+  describe "faking classes" do
+    class ThisClassWillBeReplaced
+      def self.hello(name)
+        "Hello, #{name}"
+      end
+    end
+    TheOriginalClass = ThisClassWillBeReplaced
+
+    after do
+      Bogus.reset_overwritten_classes
+    end
+
+    it "replaces the class for the duration of the test" do
+      Stubber.fake_class(ThisClassWillBeReplaced, hello: "replaced!")
+
+      ThisClassWillBeReplaced.hello("foo").should == "replaced!"
+      ThisClassWillBeReplaced.should_not equal(TheOriginalClass)
+    end
+
+    it "makes it possible to spy on classes" do
+      Stubber.fake_class(ThisClassWillBeReplaced)
+
+      ThisClassWillBeReplaced.hello("foo")
+
+      ThisClassWillBeReplaced.should Bogus.have_received.hello("foo")
+      ThisClassWillBeReplaced.should_not Bogus.have_received.hello("bar")
+    end
+
+    it "restores the class after the test has finished" do
+      Stubber.fake_class(ThisClassWillBeReplaced)
+      Bogus.reset_overwritten_classes
+
+      ThisClassWillBeReplaced.should equal(TheOriginalClass)
+    end
+  end
+
+  class SampleForContracts
+    def initialize(name)
+      @name = name
+    end
+
+    def greet(greeting = "Hello")
+      "#{greeting}, #{@name}!"
+    end
+  end
+
+  describe "contracts" do
+    let(:sample) { SampleForContracts.new("John") }
+
+    before do
+      Bogus.reset!
+
+      Stubber.fake(:sample_for_contracts, greet: "Welcome, John!")
+
+      Bogus.after_each_test
+
+      Bogus.record_calls_for(:sample_for_contracts)
+    end
+
+    it "passes when all the mocked interactions were executed" do
+      sample.greet("Welcome").should == "Welcome, John!"
+
+      Bogus.after_each_test
+
+      expect {
+        Bogus.verify_contract!(:sample_for_contracts)
+      }.not_to raise_error
+    end
+
+    it "fails when contracts are fullfilled" do
+      sample.greet("Hello").should == "Hello, John!"
+
+      Bogus.after_each_test
+
+      expect {
+        Bogus.verify_contract!(:sample_for_contracts)
+      }.to raise_error(Bogus::ContractNotFulfilled)
+    end
+  end
 end