facon 0.1

data/History.txt

@@ -0,0 +1,5 @@
+=== 0.1 / 2008-02-09
+
+* 1 XXX
+  * XXX
+

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/facon.rb
+lib/facon/baconize.rb
+lib/facon/core_ext/object.rb
+lib/facon/error_generator.rb
+lib/facon/expectation.rb
+lib/facon/mock.rb
+lib/facon/mockable.rb
+lib/facon/proxy.rb
+spec/baconize_spec.rb
+spec/expectation_spec.rb
+spec/mock_spec.rb
+spec/spec_helper.rb
+spec/stub_spec.rb

data/README.txt

@@ -0,0 +1,87 @@
+= Facon
+
+Facon is a mocking library in the spirit of the Bacon spec library. Small, compact, and works with Bacon.
+
+== Synopsis
+
+To use Facon with Bacon[http://rubyforge.org/projects/test-spec/], simply <code>require 'facon'</code> and you're done.
+
+You can now write Bacon specs like this (in RSpec-like style):
+
+  require 'bacon'
+  require 'facon'
+
+  describe 'PersonController' do
+    before do
+      @konata = mock('konata', :id => 1, :name => 'Konata Izumi')
+      @kagami = mock('kagami', :id => 2, :name => 'Kagami Hiiragi')
+    end
+
+    it "should find all people on GET to 'index'" do
+      Person.should.receive(:find).with(:all).and_return([@konata, @kagami])
+
+      get('/people/index')
+    end
+
+    it "should find the person with id of 1 on Get to 'show/1'" do
+      Person.should.receive(:find).with(1).and_return(@konata)
+
+      get('/people/show/1')
+    end
+  end
+
+For now, more examples can be found in the specs included with the Facon gem. I promise to get better examples into the documentation!
+
+See Facon::Baconize for more documentation on using Facon with Bacon[http://rubyforge.org/projects/test-spec/].
+
+== Requirements
+
+* Ruby 1.8
+* Bacon (optional, required for running specs)
+
+== Installation
+
+Simply install the gem:
+  gem install facon
+
+== Links
+
+* Facon website - http://facon.rubyforge.org/
+* Facon Rubyforge project - http://rubyforge.org/projects/facon/
+* Bacon - http://rubyforge.org/projects/test-spec/
+* RSpec - http://rspec.info/
+
+== Todos
+
+* test/unit and RSpec integration.
+* Remove the $facon_mocks global.
+
+== Thanks to
+
+* RSpec (http://rspec.info/) for creating spec/mocks, from which a lot of the code for Facon is stolen.
+* Christian Neukirchen (http://rubyforge.org/projects/test-spec/) for creating Bacon.
+
+== License:
+
+(The MIT License)
+
+Copyright (c) 2008 Cheah Chu Yeow
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'hoe'
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'facon'
+
+Hoe.new('facon', Facon::VERSION) do |p|
+  p.rubyforge_name = 'facon'
+  p.author = 'Cheah Chu Yeow'
+  p.email = 'chuyeow@gmail.com'
+  p.summary = 'Tiny mocking library.'
+  p.url = 'http://facon.rubyforge.org/'
+  p.description = 'A mocking library in the spirit of the Bacon spec library. Small, compact, and works with Bacon.'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = 'rdocs'
+  # p.clean_globs = ['test/actual'] # Remove this directory on "rake clean"
+end

data/lib/facon.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'facon/mockable'
+require 'facon/mock'
+require 'facon/error_generator'
+require 'facon/expectation'
+require 'facon/proxy'
+require 'facon/baconize'
+
+require 'facon/core_ext/object'
+
+# Facon is a mocking library in the spirit of the Bacon spec library. Small,
+# compact, and works with Bacon.
+module Facon
+  VERSION = '0.1'
+end

data/lib/facon/baconize.rb

@@ -0,0 +1,95 @@
+module Facon
+  # == Bacon integration
+  #
+  # To use Facon with Bacon, simply <code>require 'facon'</code>. Facon injects
+  # itself into Bacon if it can find it, so all you have to do is to make sure
+  # you have Bacon and Facon available on the load path.
+  #
+  # == Example
+  #
+  # In <code>spec_helper.rb</code>:
+  #   require 'rubygems'
+  #   require 'bacon'
+  #   require 'facon'
+  #
+  # Simply <code>require</code> your <code>spec_helper.rb</code> in your specs and you are now
+  # able to create mocks and expectations:
+  #
+  #   require '/path/to/spec_helper'
+  #
+  #   describe 'My examples' do
+  #     it "should allow mocks and expectations" do
+  #       @mock = mock('test mock')
+  #       @mock.should.receive(:message).and_return(:foo)
+  #
+  #       do_something_with(@mock)
+  #     end
+  #   end
+  module Baconize
+
+    # Mixin intended for Bacon::Context so that it runs spec_verify on all mocks
+    # after each example.
+    module ContextExtensions
+      def self.included(base)
+        base.class_eval do
+          alias_method :it_without_mock_verification, :it
+          alias_method :it, :it_with_mock_verification
+        end
+      end
+
+      def setup_facon_mocks
+        $facon_mocks ||= []
+      end
+
+      def verify_facon_mocks
+        $facon_mocks.each { |mock| mock.spec_verify }
+      end
+
+      def it_with_mock_verification(description, &block)
+        setup_facon_mocks
+        it_without_mock_verification(description, &block)
+        verify_facon_mocks
+      end
+    end
+
+    # Mixin intended for Bacon's Should class so that we can do
+    # mock.should.receive(:message) and mock.should.not.receive(:message).
+    module ShouldExtensions
+      def self.included(base)
+        # Remove Facon::Mockable methods we mixed in to Object, since we don't
+        # need those in the Should class.
+        base.class_eval do
+          instance_methods.each do |method|
+            undef_method(method) if Facon::Mockable.public_instance_methods.include?(method)
+          end
+        end
+      end
+
+      def receive(method, &block)
+        if @negated
+          @object.mock_proxy.add_negative_expectation(caller(1)[0], method, &block)
+        else
+          @object.mock_proxy.add_expectation(caller(1)[0], method, &block)
+        end
+      end
+
+      private
+        def mock_proxy
+          @mock_proxy ||= Proxy.new(@object, Mock === @object ? @object.name : @object.class.name)
+        end
+    end
+  end
+end
+
+
+begin
+  Bacon::Context.class_eval { include Facon::Baconize::ContextExtensions }
+  Should.class_eval { include Facon::Baconize::ShouldExtensions }
+rescue NameError
+  require 'rubygems'
+  require 'bacon'
+  Bacon::Context.class_eval { include Facon::Baconize::ContextExtensions }
+  Should.class_eval { include Facon::Baconize::ShouldExtensions }
+rescue LoadError
+  puts 'Bacon is not available.'
+end

data/lib/facon/core_ext/object.rb

@@ -0,0 +1,3 @@
+class Object #:nodoc:
+  include Facon::Mockable
+end

data/lib/facon/error_generator.rb

@@ -0,0 +1,42 @@
+module Facon
+  # A helper class for generating errors for expectation errors on mocks.
+  class ErrorGenerator
+    def initialize(target, name)
+      @target, @name = target, name
+    end
+
+    def raise_expectation_error(expectation)
+      message = "#{target_name} expected :#{expectation.method} with #{format_args(*expectation.argument_expectation)} #{format_count(expectation.expected_received_count)}, but received it #{format_count(expectation.actual_received_count)}"
+      raise(Facon::MockExpectationError, message)
+    end
+
+    def raise_unexpected_message_error(method, *args)
+      raise(Facon::MockExpectationError, "#{target_name} received unexpected message :#{method} with #{format_args(*args)}")
+    end
+
+    def raise_unexpected_message_args_error(expectation, *args)
+      message = "#{target_name} expected :#{expectation.method} with #{format_args(*expectation.argument_expectation)}, but received it with #{format_args(*args)}"
+      raise(Facon::MockExpectationError, message)
+    end
+
+    def raise_block_failed_error(method, exception_message)
+      message = "#{target_name} received :#{method} but passed block failed with: #{exception_message}"
+      raise(Facon::MockExpectationError, message)
+    end
+
+    private
+      def target_name
+        @name ? "Mock '#{@name}'" : @target.inspect
+      end
+
+      def format_args(*args)
+        return '(no args)' if args.empty?
+        return '(any args)' if args == [:any]
+        "(#{args.map { |a| a.inspect }.join(', ')})"
+      end
+
+      def format_count(count)
+        count == 1 ? '1 time' : "#{count} times"
+      end
+  end
+end

data/lib/facon/expectation.rb

@@ -0,0 +1,130 @@
+require 'forwardable'
+
+module Facon
+  # An Expectation, also know as a mock method, is an expectation that an object
+  # should receive a specific message during the execution of an example.
+  class Expectation
+    extend ::Forwardable
+    def_delegators :@error_generator, :raise_expectation_error, :raise_block_failed_error
+
+    attr_reader :error_generator, :expectation_ordering, :expected_from, :method, :method_block, :expected_received_count, :actual_received_count, :argument_expectation
+
+    def initialize(error_generator, expectation_ordering, expected_from, method, method_block, expected_received_count = 1)
+      @error_generator = error_generator
+      @expectation_ordering = expectation_ordering
+      @expected_from = expected_from
+      @method = method
+      @method_block = method_block
+      @expected_received_count = expected_received_count
+
+      @argument_expectation = :any
+      @exception_to_raise = nil
+      @symbol_to_throw = nil
+      @actual_received_count = 0
+      @args_to_yield = []
+    end
+
+    # Sets up the expected method to return the given value.
+    def and_return(value)
+      raise MockExpectationError, 'Ambiguous return expectation' unless @method_block.nil?
+
+      @return_block = lambda { value }
+    end
+
+    # Sets up the expected method to yield with the given arguments.
+    def and_yield(*args)
+      @args_to_yield << args
+      self
+    end
+
+    # Sets up the expected method to raise the given <code>exception</code>
+    # (default: Exception).
+    def and_raise(exception = Exception)
+      @exception_to_raise = exception
+    end
+
+    # Sets up the expected method to throw the given <code>symbol</code>.
+    def and_throw(sym)
+      @symbol_to_throw = sym
+    end
+
+    def with(*args, &block)
+      @method_block = block if block
+      @argument_expectation = args
+      self
+    end
+
+    def invoke(args, block)
+      begin
+        raise @exception_to_raise unless @exception_to_raise.nil?
+        throw @symbol_to_throw unless @symbol_to_throw.nil?
+
+        return_value = if !@method_block.nil?
+          invoke_method_block(args)
+        elsif @args_to_yield.size > 0
+          @args_to_yield.each { |curr_args| block.call(*curr_args) }
+        else
+          nil
+        end
+
+        if @return_block
+          args << block unless block.nil?
+          @return_block.call(*args)
+        else
+          return_value
+        end
+      ensure
+        @actual_received_count += 1
+      end
+    end
+
+    # Returns true if this expectation has been met.
+    # TODO at_least and at_most conditions
+    def met?
+      return true if @expected_received_count == :any ||
+        @expected_received_count == @actual_received_count
+
+      raise_expectation_error(self)
+    end
+
+    # Returns true if the given <code>method</code> and arguments match this
+    # Expectation.
+    def matches(method, args)
+      @method == method && check_arguments(args)
+    end
+
+    # Returns true if the given <code>method</code> matches this Expectation,
+    # but the given arguments don't.
+    def matches_name_but_not_args(method, args)
+      @method == method && !check_arguments(args)
+    end
+
+    def negative_expectation_for?(method)
+      false
+    end
+
+    private
+      def check_arguments(args)
+        case @argument_expectation
+        when :any then true
+        when args then true
+        end
+      end
+
+      def invoke_method_block(args)
+        @method_block.call(*args)
+      rescue => e
+        raise_block_failed_error(@method, e.message)
+      end
+  end
+
+  class NegativeExpectation < Expectation
+    def initialize(error_generator, expectation_ordering, expected_from, method, method_block, expected_received_count = 0)
+      super(error_generator, expectation_ordering, expected_from, method, method_block, expected_received_count)
+    end
+
+    def negative_expectation_for?(method)
+      @method == method
+    end
+  end
+end

data/lib/facon/mock.rb

@@ -0,0 +1,41 @@
+module Facon
+  # Error returned when an expectation on a mock is not satisfied.
+  class MockExpectationError < StandardError
+  end
+
+  # A mock object is a 'fake' object on which you can impose simulated behavior.
+  # Defining expectations and stubs on mock objects allows you to specify
+  # object collaboration without needing to actually instantiate those
+  # collaborative objects.
+  #
+  # == Examples
+  #
+  #   mock = mock('A name')
+  #   mock = mock('Mock person', :name => 'Konata', :sex => 'female')
+  class Mock
+    include Facon::Mockable
+
+    attr_accessor :name
+
+    def initialize(name, stubs = {})
+      @name = name
+      stub_out(stubs)
+    end
+
+    def method_missing(method, *args, &block)
+      super(method, *args, &block)
+    rescue NameError
+      # An unexpected method was called on this mock.
+      mock_proxy.raise_unexpected_message_error(method, *args)
+    end
+
+    private
+
+      # Stubs out all the given stubs.
+      def stub_out(stubs)
+        stubs.each_pair do |method, response|
+          stub!(method).and_return(response)
+        end
+      end
+  end
+end

data/lib/facon/mockable.rb

@@ -0,0 +1,43 @@
+module Facon
+  # A module containing convenient methods for creating mocks, stubs and
+  # expectations.
+  module Mockable
+
+    # Shortcut for creating a Facon::Mock instance.
+    #
+    # == Example
+    #
+    #   mock = mock('test mock', :foo => 'bar')
+    #   mock.foo # => 'bar'
+    def mock(name, stubs = {})
+      Mock.new(name, stubs)
+    end
+
+    def stub!(method)
+      mock_proxy.add_stub(caller(1)[0], method)
+    end
+
+    def should_receive(method, &block)
+      mock_proxy.add_expectation(caller(1)[0], method, &block)
+    end
+
+    def should_not_receive(method, &block)
+      mock_proxy.add_negative_expectation(caller(1)[0], method, &block)
+    end
+
+    # Verifies that the expectations set on this mock are all met, otherwise
+    # raises a MockExpectationError.
+    def spec_verify
+      mock_proxy.verify
+    end
+
+    def spec_reset
+      mock_proxy.reset
+    end
+
+    # Returns the mock proxy object.
+    def mock_proxy
+      @mock_proxy ||= Proxy.new(self, Mock === self ? @name : self.class.name)
+    end
+  end
+end

data/lib/facon/proxy.rb

@@ -0,0 +1,99 @@
+require 'forwardable'
+
+module Facon
+  # A proxy for mock objects. Stubs and expectations are set on this proxy.
+  class Proxy
+    extend ::Forwardable
+    def_delegators :@error_generator, :raise_unexpected_message_error, :raise_unexpected_message_args_error
+  
+    def initialize(target, name)
+      @target, @name = target, name
+      @expectations = []
+      @stubs = []
+      @error_generator = ErrorGenerator.new(target, name)
+    end
+
+    def add_stub(expected_from, method)
+      $facon_mocks << (@target) unless $facon_mocks.nil?
+      define_expected_method(method)
+
+      # A stub is really an expectation that can be called any number of times.
+      @stubs.unshift(Expectation.new(@error_generator, @expectation_ordering, expected_from, method, nil, :any))
+      @stubs.first
+    end
+
+    def add_expectation(expected_from, method, &block)
+      $facon_mocks << (@target) unless $facon_mocks.nil?
+      define_expected_method(method)
+
+      @expectations << Expectation.new(@error_generator, @expectation_ordering, expected_from, method, (block_given? ? block : nil), 1)
+      @expectations.last
+    end
+
+    def add_negative_expectation(expected_from, method, &block)
+      $facon_mocks << (@target) unless $facon_mocks.nil?
+      define_expected_method(method)
+
+      @expectations << NegativeExpectation.new(@error_generator, @expectation_ordering, expected_from, method, (block_given? ? block : nil))
+      @expectations.last
+    end
+
+    def message_received(method, *args, &block)
+      if expectation = find_matching_expectation(method, *args)
+        expectation.invoke(args, block)
+      elsif stub = find_matching_method_stub(method, *args)
+        stub.invoke([], block)
+      elsif expectation = find_almost_matching_expectation(method, *args)
+        raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(method)
+      else
+        @target.send(:method_missing, method, *args, &block)
+      end
+    end
+
+    def verify
+      @expectations.each { |expectation| expectation.met? }
+    ensure
+      reset
+    end
+
+    def reset
+      @expectations.clear
+      @stubs.clear
+    end
+
+    private
+      # Defines an expected method that simply calls the
+      # <code>message_received</code> method.
+      def define_expected_method(method)
+        metaclass_eval(<<-EOF, __FILE__, __LINE__)
+          def #{method}(*args, &block)
+            mock_proxy.message_received(:#{method}, *args, &block)
+          end
+        EOF
+      end
+
+      def metaclass
+        (class << @target; self; end)
+      end
+
+      def metaclass_eval(str, filename, lineno)
+        metaclass.class_eval(str, filename, lineno)
+      end
+
+      def find_matching_expectation(method, *args)
+        @expectations.find { |expectation| expectation.matches(method, args) }
+      end
+
+      def find_almost_matching_expectation(method, *args)
+        @expectations.find { |expectation| expectation.matches_name_but_not_args(method, args) }
+      end
+
+      def find_matching_method_stub(method, *args)
+        @stubs.find { |stub| stub.matches(method, args) }
+      end
+
+      def has_negative_expectation?(method)
+        @expectations.find { |expectation| expectation.negative_expectation_for?(method) }
+      end
+  end
+end

data/spec/baconize_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Facon::Baconize" do
+
+  before do
+    @mock = Facon::Mock.new('test mock')
+  end
+
+  it "should make the #receive instance method available to Should" do
+    Should.public_instance_methods.should.include?('receive')
+  end
+
+  it "should allow expectations on mocks with should.receive(:message)" do
+    @mock.should.receive(:message).and_return(:foo)
+
+    @mock.message.should == :foo
+  end
+
+  it "should allow expectations on mocks with should.not.receive(:message)" do
+    @mock.should.not.receive(:message)
+
+    @mock.to_s
+    # FIXME: needs a better test on the actual error raised, but the
+    # instance_eval in it() makes it hard.
+  end
+
+  it "should allow expectations on arbitrary objects with should.receive(:message)" do
+    Object.should.receive(:message).and_return(:foo)
+    @object = Object.new
+    @object.should.receive(:message).and_return(:bar)
+
+    Object.message.should == :foo
+    @object.message.should == :bar
+  end
+end

data/spec/expectation_spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "A mock object" do
+  before do
+    @mock = Facon::Mock.new('test mock')
+  end
+
+  after do
+    @mock.spec_reset
+  end
+
+  def verify_mock
+    lambda { @mock.spec_verify }.should.not.raise(Facon::MockExpectationError)
+  end
+
+  it "should pass when not receiving message specified as not to be received" do
+    @mock.should_not_receive(:not_expected)
+
+    verify_mock
+  end
+
+  it "should pass when receiving message specified as not to be received with different args" do
+    @mock.should_not_receive(:message).with(:not_this)
+    @mock.should_receive(:message).with(:but_this)
+    @mock.message(:but_this)
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError when receiving message specified as not to be received" do
+    @mock.should_not_receive(:not_expected)
+    @mock.not_expected
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :not_expected with (any args) 0 times, but received it 1 time" 
+  end
+
+  it "should raise a MockExpectationError when receiving message specified as not to be received with arguments" do
+    @mock.should_not_receive(:not_expected).with(:unexpected_arg)
+    @mock.not_expected(:unexpected_arg)
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :not_expected with (:unexpected_arg) 0 times, but received it 1 time"
+  end
+
+  it "should pass when receiving message specified as not to be received, but with wrong arguments" do
+    @mock.should_not_receive(:not_expected).with(:unexpected_arg)
+    @mock.not_expected(:wrong_arg)
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError when receiving message specified as to be received is not called" do
+    @mock.should_receive(:expected_message)
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :expected_message with (any args) 1 time, but received it 0 times"
+  end
+
+  it "should raise a MockExpectationError when receiving message specified as to be received, but with wrong arguments" do
+    @mock.should_receive(:expected_message).with(:expected_arg)
+
+    lambda {
+      @mock.expected_message(:unexpected_arg)
+    }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :expected_message with (:expected_arg), but received it with (:unexpected_arg)"
+  end
+
+  it "should raise a MockExpectationError when receiving an unexpected message" do
+    lambda {
+      @mock.not_expected
+    }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' received unexpected message :not_expected with (no args)"
+  end
+
+  it "should raise a MockExpectationError when receiving an unexpected message with arguments" do
+    lambda {
+      @mock.not_expected(:foo, :bar)
+    }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' received unexpected message :not_expected with (:foo, :bar)"
+  end
+
+  it "should use block for expectation if provided" do
+    @mock.should_receive(:expected_message) do |a, b|
+      a.should == :first
+      b.should == :second
+      'foo'
+    end
+
+    @mock.expected_message(:first, :second).should == 'foo'
+
+    verify_mock
+  end
+
+  it "should use block with given arguments for expectation if provided" do
+    @mock.should_receive(:expected_message).with(:expected_arg) do |arg|
+      arg.should == :expected_arg
+      'foo'
+    end
+
+    @mock.expected_message(:expected_arg).should == 'foo'
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError if block for expectation fails" do
+    @mock.should_receive(:expected_message) do |arg|
+      arg.should == :expected_arg
+    end
+
+    lambda {
+      @mock.expected_message(:unexpected_arg)
+    }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' received :expected_message but passed block failed with: :unexpected_arg.==(:expected_arg) failed"
+  end
+
+  it "should raise a MockExpectationError if there's a block for expectation and an #and_return expectation is also set" do
+    lambda {
+      @mock.should_receive(:foo) do
+        :this
+      end.and_return(:that)
+    }.should.raise(Facon::MockExpectationError).message.should == 'Ambiguous return expectation'
+  end
+end
+
+
+
+
+
+
+

data/spec/mock_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Facon::Mock" do
+  before do
+    @mock = Facon::Mock.new('test mock')
+  end
+
+  it "should stub out a method on a mock" do
+    @mock.stub!(:stubbed_method).and_return(:stub_value)
+
+    @mock.stubbed_method.should == :stub_value
+    @mock.stubbed_method.should == :stub_value # called twice to ensure it stays
+  end
+
+  it "should stub out a method on a non-mock" do
+    non_mock = Object.new
+    non_mock.stub!(:stubbed_method).and_return(:stub_value)
+
+    non_mock.stubbed_method.should == :stub_value
+    non_mock.stubbed_method.should == :stub_value # called twice to ensure it stays
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bacon'
+
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+require 'facon'

data/spec/stub_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "A method stub" do
+  before do
+    @class = Class.new do
+      def self.existing_class_method
+        :original_value
+      end
+
+      def existing_instance_method
+        :original_value
+      end
+    end
+    @object = @class.new
+  end
+
+  it "should override existing methods" do
+    @object.existing_instance_method.should == :original_value
+    @object.stub!(:existing_instance_method).and_return(:stubbed_value)
+
+    @object.existing_instance_method.should == :stubbed_value
+  end
+
+  it "should return the expected value given to #and_return when the stubbed method is received" do
+    @object.stub!(:stubbed_method).and_return(:stubbed_value)
+
+    @object.stubbed_method.should == :stubbed_value
+  end
+
+  it "should ignore when the stubbed method is received" do
+    @object.stub!(:stubbed_method)
+
+    lambda {
+      @object.stubbed_method
+    }.should.not.raise
+  end
+
+  it "should ignore when the stubbed method is received with arguments" do
+    @object.stub!(:stubbed_method)
+
+    lambda {
+      @object.stubbed_method(:some_arg)
+    }.should.not.raise
+  end
+
+  it "should yield the argument given to #and_yield" do
+    @object.stub!(:yielding_method).and_yield(:yielded)
+
+    yielded = nil
+    @object.yielding_method { |arg| yielded = arg }
+
+    yielded.should == :yielded
+  end
+
+  it "should yield the multiple arguments given to #and_yield" do
+    @object.stub!(:yielding_method).and_yield(:first, :second)
+
+    first_arg, second_arg = nil, nil
+    @object.yielding_method { |arg1, arg2| first_arg, second_arg = arg1, arg2 }
+
+    first_arg.should == :first
+    second_arg.should == :second
+  end
+
+  it "should yield multiple times with multiple calls to #and_yield (i.e. allow chaining of #and_yield calls)" do
+    @object.stub!(:yielding_method).and_yield(:one).and_yield(:two)
+
+    yielded = []
+    @object.yielding_method { |arg| yielded << arg }
+
+    yielded.should == [:one, :two]
+  end
+
+  it "should be able to yield and return different objects (i.e. allow #and_yield and #and_return chaining)" do
+    @object.stub!(:yield_and_return).and_yield(:yielded).and_return(:returned)
+
+    yielded = nil
+    @object.yield_and_return { |arg| yielded = arg }.should == :returned
+
+    yielded.should == :yielded
+  end
+
+  it "should raise the expected exception given to #and_raise" do
+    @object.stub!(:failing_method).and_raise(RuntimeError)
+
+    lambda { @object.failing_method }.should.raise(RuntimeError)
+  end
+
+  it "should throw the expected thrown value given to #and_throw" do
+    @object.stub!(:pitch).and_throw(:ball)
+
+    lambda { @object.pitch }.should.throw(:ball)
+  end
+
+  it "should ignore when the stubbed method is never called" do
+  end
+end
+
+describe "A method stub with arguments" do
+
+  before do
+    @object = Object.new
+    @object.stub!(:stubbed_method).with(:expected_arg).and_return(:stubbed_value)
+  end
+
+  it "should ignore when never called" do
+  end
+
+  it "should ignore when called with expected argument" do
+    @object.stubbed_method(:expected_arg)
+  end
+
+  it "should raise a NoMethodError when called with no arguments" do
+    lambda { @object.stubbed_method }.should.raise(NoMethodError)
+  end
+
+  it "should raise a NoMethodError when called with some other argument" do
+    lambda { @object.stubbed_method(:something_else) }.should.raise(NoMethodError)
+  end
+
+  it "should allow another stub with different arguments" do
+    @object.stub!(:stubbed_method).with(:something_else).and_return(:bar)
+
+    @object.stubbed_method(:expected_arg).should == :stubbed_value
+    @object.stubbed_method(:something_else).should == :bar
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: facon
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Cheah Chu Yeow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-02-10 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.0
+    version: 
+description: A mocking library in the spirit of the Bacon spec library. Small, compact, and works with Bacon.
+email: chuyeow@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/facon.rb
+- lib/facon/baconize.rb
+- lib/facon/core_ext/object.rb
+- lib/facon/error_generator.rb
+- lib/facon/expectation.rb
+- lib/facon/mock.rb
+- lib/facon/mockable.rb
+- lib/facon/proxy.rb
+- spec/baconize_spec.rb
+- spec/expectation_spec.rb
+- spec/mock_spec.rb
+- spec/spec_helper.rb
+- spec/stub_spec.rb
+has_rdoc: true
+homepage: http://facon.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: facon
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Tiny mocking library.
+test_files: []
+