bogus 0.0.1

data/spec/bogus/interaction_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Bogus::Interaction do
+  class SomeError < StandardError; end
+
+  same = [
+    [[:foo, [:bar], "value"], [:foo, [:bar], "value"]],
+    [[:foo, [:bar]], [:foo, [:bar], "value"]],
+    [[:foo, [:bar], "value"], [:foo, [:bar]]],
+    [[:foo, [:bar]], [:foo, [:bar]]]
+  ]
+
+  different = [
+    [[:foo, [:bar], "value"], [:foo, [:bar], "value2"]],
+    [[:foo, [:bar], "value"], [:baz, [:bar], "value"]],
+    [[:foo, [:baz], "value"], [:foo, [:bar], "value"]],
+    [[:foo, [:bar]], [:foo, [:baz]]],
+    [[:baz, [:bar]], [:foo, [:bar]]]
+  ]
+
+  def create_interaction(interaction)
+    method_name, args, return_value = interaction
+    if return_value
+      Bogus::Interaction.new(method_name, args) { return_value }
+    else
+      Bogus::Interaction.new(method_name, args)
+    end
+  end
+
+  same.each do |first_interaction, second_interaction|
+    it "returns true for #{first_interaction.inspect} and #{second_interaction.inspect}" do
+      first = create_interaction(first_interaction)
+      second = create_interaction(second_interaction)
+
+      first.should == second
+    end
+  end
+
+  different.each do |first_interaction, second_interaction|
+    it "returns false for #{first_interaction.inspect} and #{second_interaction.inspect}" do
+      first = create_interaction(first_interaction)
+      second = create_interaction(second_interaction)
+
+      first.should_not == second
+    end
+  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.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.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.should == second
+  end
+end

data/spec/bogus/interactions_repository_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Bogus::InteractionsRepository do
+  let(:interactions_repository) { Bogus::InteractionsRepository.new }
+
+  def recorded?(fake_name, method, *args)
+    interactions_repository.recorded?(fake_name, Bogus::Interaction.new(method, args))
+  end
+
+  it "considers the interaction recorded if it was recorded previously" do
+    interactions_repository.record(:foo, :bar, 1, 2, 3)
+
+    recorded?(:foo, :bar, 1, 2, 3).should be_true
+  end
+
+  it "considers the interaction recorded if it returned the same value as passed block" do
+    interactions_repository.record(:foo, :bar) { "a result" }
+    interaction = Bogus::Interaction.new(:bar, []) { "a result" }
+
+    interactions_repository.recorded?(:foo, interaction).should be_true
+  end
+
+  it "does not consider any interactions recorded prior to any recordings" do
+    recorded?(:foo, :bar, 1).should be_false
+  end
+
+  it "does not consider the interaction recorded with a different fake name"  do
+    interactions_repository.record(:baz, :bar, 1)
+
+    recorded?(:foo, :bar, 1).should be_false
+  end
+
+  it "does not consider the interaction recorded with a different method name" do
+    interactions_repository.record(:foo, :baz, 1)
+
+    recorded?(:foo, :bar, 1).should be_false
+  end
+
+  it "does not consider the interaction recorded with different method arguments" do
+    interactions_repository.record(:foo, :bar, 1, 2)
+
+    recorded?(:foo, :bar, 1).should be_false
+  end
+
+  it "returns a list of interactions for given fake" do
+    interactions_repository.record(:foo, :bar, 1, 2)
+
+    interactions_repository.for_fake(:foo).should == [Bogus::Interaction.new(:bar, [1, 2])]
+  end
+end

data/spec/bogus/invocation_matcher_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Bogus::InvocationMatcher do
+  let(:object) { stub }
+  let(:method) { nil }
+  let(:records_double_interactions) { stub }
+  let(:verifies_stub_definition) { stub }
+
+  let(:invocation_matcher) { isolate(Bogus::InvocationMatcher) }
+
+  before do
+    stub(verifies_stub_definition).verify!
+    stub(records_double_interactions).record
+
+    invocation_matcher.the_method(:foo, :bar)
+    invocation_matcher.matches?(object)
+  end
+
+  it "verifies stub definition" do
+    verifies_stub_definition.should have_received.verify!(object, :the_method, [:foo, :bar])
+  end
+
+  it "records double interacions" do
+    records_double_interactions.should have_received.record(object, :the_method, [:foo, :bar])
+  end
+end

data/spec/bogus/mocking_dsl_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Bogus::MockingDSL do
+  class ExampleFoo
+    def foo(bar)
+    end
+  end
+
+  class Stubber
+    extend Bogus::MockingDSL
+  end
+
+  describe "#stub" do
+    it "allows stubbing the existing methods" do
+      baz = ExampleFoo.new
+
+      Stubber.stub(baz).foo("bar") { :return_value }
+
+      baz.foo("bar").should == :return_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
+  end
+
+  describe "#have_received" do
+    context "with a fake object" do
+      let(:the_fake) { Bogus.fake_for(:example_foo) }
+
+      it "allows verifying that fakes have correct interfaces" do
+        the_fake.foo("test")
+
+        the_fake.should Stubber.have_received.foo("test")
+      end
+
+      it "does not allow verifying on non-existent methods" do
+        expect {
+          the_fake.should Stubber.have_received.bar("test")
+        }.to raise_error(NameError)
+      end
+
+      it "does not allow verifying on methods with a wrong argument count" do
+        expect {
+          the_fake.should Stubber.have_received.foo("test", "test 2")
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "can be used with plain old Ruby objects" do
+      object = ExampleFoo.new
+      stub(object).foo
+
+      object.foo('test')
+
+      object.should Stubber.have_received.foo("test")
+    end
+  end
+
+  class Mocker
+    extend Bogus::MockingDSL
+  end
+
+  describe "#mock" do
+    it "allows mocking the existing methods" do
+      baz = ExampleFoo.new
+
+      Mocker.mock(baz).foo("bar") { :return_value }
+
+      baz.foo("bar").should == :return_value
+    end
+  end
+end

data/spec/bogus/overwrites_classes_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Bogus::OverwritesClasses do
+  module SampleOuterModule
+    module SampleModule
+      class SampleClass
+      end
+    end
+  end
+
+  let(:new_class) { Class.new }
+  let(:overwrites_classes) { Bogus::OverwritesClasses.new }
+
+  it "overwrites nested classes" do
+    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)
+
+    SampleOuterModule.should equal(new_class)
+  end
+end
+

data/spec/bogus/proxy_class_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Bogus::ProxyClass do
+  module SampleModule
+    class GrandLibrary
+      def checkout(book, user)
+        :checkouted
+      end
+
+      def self.find_by_address(address)
+        :the_library
+      end
+
+      def self.find_by_isbn(isbn)
+        raise StandardError
+      end
+    end
+  end
+
+  let(:proxy_class) { Bogus::ProxyClass.new(:fake_name, SampleModule::GrandLibrary, create_recording_proxy) }
+
+  let(:create_recording_proxy) do
+    lambda {|instance, fake_name| Bogus::RecordingProxy.new(instance, fake_name, interactions_repository) }
+  end
+
+  let(:interactions_repository) { FakeRepository.new }
+
+  it "returns the proxy" do
+    proxy_class.new.checkout("Moby Dick", "Bob").should == :checkouted
+  end
+
+  it "records interactions with created objects" do
+    proxy_class.new.checkout("Moby Dick", "Bob")
+
+    interactions_repository.should have_recorded(:fake_name, :checkout, "Moby Dick", "Bob")
+  end
+
+  it "responds to every method that the original class responds to" do
+    proxy_class.should respond_to(:find_by_address)
+  end
+
+  it "delegates interactions with the proxy class to wrapped class" do
+    proxy_class.find_by_address("some address").should == :the_library
+  end
+
+  it "records interactions with the proxy class" do
+    proxy_class.find_by_address("some address")
+
+    interactions_repository.should have_recorded(:fake_name, :find_by_address, "some address")
+  end
+
+  it "records return values" do
+    proxy_class.find_by_address("some address")
+
+    interactions_repository.return_value(:fake_name, :find_by_address, "some address").should == :the_library
+  end
+
+  it "re-raises exceptions" do
+    expect {
+      proxy_class.find_by_isbn("some isbn")
+    }.to raise_error(StandardError)
+  end
+
+  it "records raised exceptions" do
+    proxy_class.find_by_isbn("some isbn") rescue nil
+
+    expect {
+      interactions_repository.return_value(:fake_name, :find_by_isbn, "some isbn")
+    }.to raise_error(StandardError)
+  end
+
+  class FakeRepository
+    def initialize
+      @recordings = []
+    end
+
+    def record(fake_name, method, *args, &block)
+      @recordings << [fake_name, method, args, block]
+    end
+
+    def has_recorded?(fake_name, method, *args)
+      !!find(fake_name, method, *args)
+    end
+
+    def return_value(fake_name, method, *args)
+      find(fake_name, method, *args).last.call
+    end
+
+    def find(fake_name, method, *args)
+      @recordings.find do |f, m, a, b|
+        [f, m, a] == [fake_name, method, args]
+      end
+    end
+  end
+end

data/spec/bogus/record_interactions_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Bogus::RecordInteractions do
+
+  class SampleRecordsInteractions
+    include Bogus::RecordInteractions
+  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)
+  end
+
+  it "allows verifying that interactions didn't happen" do
+    sample.__record__(:bar)
+
+    sample.__inner_object__.should_not have_received.foo
+  end
+
+  it "returns self from record" do
+    sample.__record__(:foo).should == sample
+  end
+end

data/spec/bogus/records_double_interactions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Bogus::RecordsDoubleInteractions do
+  let(:fake_registry) { stub }
+  let(:doubled_interactions) { stub }
+  let(:object) { Object.new }
+
+  let(:records_double_interactions) { isolate(Bogus::RecordsDoubleInteractions) }
+
+  it "records the call in double interaction repository" do
+    stub(fake_registry).name(object) { :object_name }
+    stub(doubled_interactions).record
+
+    records_double_interactions.record(object, :method_name, [:foo, 1])
+
+    doubled_interactions.should have_received.record(:object_name, :method_name, :foo, 1)
+  end
+
+  it "does not record the interaction if object is not a fake" do
+    stub(fake_registry).name(object) { nil }
+    dont_allow(doubled_interactions).record
+
+    records_double_interactions.record(object, :method_name, [:foo, 1])
+  end
+end

data/spec/bogus/registers_created_fakes_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Bogus::RegistersCreatedFakes do
+  let(:fake_registry) { stub }
+  let(:creates_fakes) { stub }
+
+  let(:registers_created_fakes) { isolate(Bogus::RegistersCreatedFakes) }
+
+  before do
+    stub(fake_registry).store
+    stub(creates_fakes).create { :the_fake }
+  end
+
+  it "registers the fakes created by creates_fakes" do
+    registers_created_fakes.create(:foo, as: :instance) { Object }
+
+    fake_registry.should have_received.store(:foo, :the_fake)
+  end
+
+  it "returns the created fake" do
+    fake = registers_created_fakes.create(:foo, as: :instance) { Object }
+
+    fake.should == :the_fake
+  end
+end

data/spec/bogus/verifies_contracts_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Bogus::VerifiesContracts do
+  let(:real_interactions) { stub }
+  let(:doubled_interactions) { stub }
+  let(:verifies_contracts) { isolate(Bogus::VerifiesContracts) }
+
+  let(:matched_interaction) { interaction("matched") }
+
+  it "fails unmatched calls" do
+    first_interaction = interaction("first")
+    second_interaction = interaction("second")
+
+    stub(doubled_interactions).for_fake(:fake_name){[first_interaction, matched_interaction, second_interaction]}
+
+    stub(real_interactions).recorded?(:fake_name, first_interaction) { false }
+    stub(real_interactions).recorded?(:fake_name, second_interaction) { false }
+    stub(real_interactions).recorded?(:fake_name, matched_interaction) { true }
+
+    expect_verify_to_raise_error_with_interactions(:fake_name, [first_interaction, second_interaction])
+  end
+
+  it "passes with all calls matched" do
+    stub(doubled_interactions).for_fake(:fake_name) { [matched_interaction] }
+    stub(real_interactions).recorded?(:fake_name, matched_interaction) { true }
+
+    expect {
+      verifies_contracts.verify(:fake_name)
+    }.not_to raise_error
+  end
+
+  def expect_verify_to_raise_error_with_interactions(name, interactions)
+    verifies_contracts.verify(name)
+    fail
+  rescue Bogus::ContractNotFulfilled => contract_error
+    contract_error.interactions.should == { name => interactions }
+  end
+
+  def interaction(method)
+    Bogus::Interaction.new(method, [:foo, :bar]) { "return value" }
+  end
+end