motion-facon 0.5.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+.repl_history
+build
+tags
+app/pixate_code.rb
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+.DS_Store
+nbproject
+.redcar
+#*#
+*~
+*.sw[po]
+.eprj
+.sass-cache
+.idea
+build/
+resources/**/*
+db/schema.xcdatamodeld

data/Changelog.txt

@@ -0,0 +1,32 @@
+=== 0.5.0
+* Added Ruby 1.9.2 compatibility. Thanks ymendel!
+* Get rid of that dependency on hoe, use Bundler to manage gem release.
+
+=== 0.4.1 / 2008-12-05
+
+* Added #times, #once and #never expectation matchers. Thanks raggi!
+  E.g. 
+    @mock.should.receive(:call_me_thrice).times(3)
+    @mock.should.receive(:just_this_1_time).once
+    @mock.should.receive(:dont_even_think_about_it).never
+
+=== 0.4.0 / 2008-12-05
+
+* Fix compatibility with Bacon 1.0 and 1.1.
+
+=== 0.3.1 / 2008-02-19
+
+* Fixed a bug where mocks were not being teared down when there is a previous spec failure.
+
+=== 0.3 / 2008-02-18
+
+* Fixed a bug with proxied methods not being cleared.
+* Fixed a bug where the same mocks were repeatedly being added to $facon_mocks.
+
+=== 0.2 / 2008-02-13
+
+* Use #after block to verify mocks so that the stack trace is more helpful (it now actually shows the line in the spec where the mock error occurred).
+
+=== 0.1 / 2008-02-09
+
+* First release!

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in motion-motion-facon.gemspec
+gemspec
+
+group :test do
+  gem 'rake'
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    motion-facon (0.5.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  motion-facon!
+  rake

data/README.md

@@ -0,0 +1,94 @@
+MotionFacon
+=====
+
+MotionFacon is a port of Facon mocking library to RubyMotion platform. It brings mocking functionality to Bacon which is
+the default (and only?) test framework for rubymotion.
+
+I tried to make minimal changes to original library and will try to keep up with upstream.
+
+Synopsis
+--------
+
+To use MotionFacon you need to install it with `gem install motion-facon` and then require it in you Rakefile with `require motion-facon.`
+
+Alternatively you can add the following to your Gemfile `gem 'motion-facon'`.
+
+You can now write [Bacon](https://github.com/chneukirchen/bacon) specs like this (in RSpec-like style):
+
+```ruby
+  describe 'PersonController' do
+    extend Facon::SpecHelpers
+
+    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])
+
+      Person.list
+    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)
+
+      Person.first
+    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](https://github.com/chneukirchen/bacon).
+
+Requirements
+------------
+
+* Recent version of RubyMotion. Tested against 1.35.
+
+
+Todos
+-----
+
+* Keep up with upstream
+
+Contributors
+------------
+
+* [James Tucker](https://github.com/raggi) for #times, #once, #never expectation matchers.
+* [Peter Kim](https://github.com/petejkim) for [MacBacon](https://github.com/alloy/MacBacon) support.
+* [Yossef Mendelssohn](https://github.com/ymendel) for Ruby 1.9.2 compatibility fixes.
+
+Thanks to
+---------
+
+* [RSpec](http://rspec.info/) for creating spec/mocks, from which a lot of the code for Facon is stolen.
+* [Christian Neukirchen](https://github.com/chneukirchen) for creating Bacon.
+* [Cheah Chu Yeow](https://github.com/chuyeow) for the original Facon gem.
+
+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,13 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require "bundler/gem_tasks"
+require "bundler/setup"
+
+$:.unshift("./lib/")
+require "./lib/motion-facon"
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'motion-facon'
+end

data/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    true
+  end
+end

data/lib/motion-facon.rb

@@ -0,0 +1,31 @@
+# Facon is a mocking library in the spirit of the Bacon spec library. Small,
+# compact, and works with Bacon.
+module Facon
+end
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  app.development do
+    base_path = "#{File.dirname(__FILE__)}"
+    files = []
+    files << 'motion-facon/mockable'
+    files << 'motion-facon/spec_helpers'
+    files << 'motion-facon/version'
+    files << 'motion-facon/error_generator'
+    files << 'motion-facon/expectation'
+    files << 'motion-facon/baconize'
+    files << 'motion-facon/mock'
+    files << 'motion-facon/proxy'
+
+
+
+    files.each do |file|
+      app.files.unshift File.expand_path "#{base_path}/#{file}.rb"
+    end
+
+    app.detect_dependencies = true
+  end
+end

data/lib/motion-facon/baconize.rb

@@ -0,0 +1,96 @@
+module Facon
+  # == Bacon integration
+  #
+  # To use Facon with Bacon, simply <code>require 'motion-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 'motion-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 teardown_facon_mocks
+        if $facon_mocks
+          $facon_mocks.each { |mock| mock.spec_reset }
+          $facon_mocks.clear
+        end
+      end
+
+      def it_with_mock_verification(description, &block)
+        @before.unshift(proc { setup_facon_mocks })
+        @after << proc { verify_facon_mocks }
+        it_without_mock_verification(description, &block)
+      ensure
+        teardown_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
+          [:"mock:",
+          :"stub!:",
+          :"should_receive:",
+          :"should_not_receive:",
+          :spec_verify,
+          :spec_reset,
+          :mock_proxy].each {|m| undef_method(m)}
+        end
+      end
+
+      def receive(method, &block)
+        Bacon::Counter[:requirements] += 1 # A should.receive expectation is also a Bacon requirement.
+        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

data/lib/motion-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/motion-facon/expectation.rb

@@ -0,0 +1,143 @@
+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
+
+    def raise_expectation_error(*args)
+      @error_generator.raise_expectation_error *args
+    end
+
+    def raise_block_failed_error(*args)
+      @error_generator.raise_block_failed_error *args
+    end
+
+    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 = proc { 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 defined?(@return_block) && @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
+
+    def times(val)
+      @expected_received_count = val
+      self
+    end
+
+    def once; times(1); end
+
+    def never; times(0); 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/motion-facon/mock.rb

@@ -0,0 +1,39 @@
+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
+    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/motion-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/motion-facon/proxy.rb

@@ -0,0 +1,132 @@
+module Facon
+  # A proxy for mock objects. Stubs and expectations are set on this proxy.
+  class Proxy
+    def raise_unexpected_message_error(*args)
+      @error_generator.raise_unexpected_message_error *args
+    end
+
+    def raise_unexpected_message_args_error(*args)
+      @error_generator.raise_unexpected_message_args_error *args
+    end
+
+    def initialize(target, name)
+      @target, @name = target, name
+      @expectations = []
+      @stubs = []
+      @proxied_methods = []
+      @error_generator = ErrorGenerator.new(target, name)
+      @expectation_ordering = nil unless defined?(@expectation_ordering)
+    end
+
+    def add_stub(expected_from, method)
+      add_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)
+      add_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)
+      add_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
+      reset_proxied_methods
+      @proxied_methods.clear
+    end
+
+    private
+      def add_method(method)
+        $facon_mocks << @target unless $facon_mocks.nil? || $facon_mocks.detect { |m| m.equal?(@target) }
+        define_expected_method(method)
+      end
+
+      # Defines an expected method that simply calls the
+      # <code>message_received</code> method.
+      def define_expected_method(method)
+        if @target.respond_to?(method) && !metaclass.method_defined?(munge(method))
+          munged_method = munge(method)
+          metaclass.instance_eval do
+            alias_method munged_method, method if method_defined?(method.to_s)
+          end
+          @proxied_methods << method
+        end
+
+        #fixme: (__FILE__, __LINE__)
+        metaclass.class_eval do
+          define_method :"#{method}" do |*args, &block|
+            mock_proxy.message_received(:"#{method}", *args, &block)
+          end
+        end
+      end
+
+      def munge(method)
+        "proxied_by_facon__#{method.to_s}".to_sym
+      end
+
+      def reset_proxied_methods
+        @proxied_methods.each do |method|
+          munged_method = munge(method)
+          metaclass.instance_eval do
+            if method_defined?(munged_method.to_s)
+              alias_method method, munged_method
+              undef_method munged_method
+            else
+              undef_method method
+            end
+          end
+        end
+      end
+
+      def metaclass
+        (class << @target; self; end)
+      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/lib/motion-facon/spec_helpers.rb

@@ -0,0 +1,9 @@
+module Facon
+  module SpecHelpers
+    def self.extended(base)
+      Object.class_eval { include Facon::Mockable }
+      base.class.class_eval { include Facon::Baconize::ContextExtensions }
+      Should.class_eval { include Facon::Baconize::ShouldExtensions }
+    end
+  end
+end

data/lib/motion-facon/version.rb

@@ -0,0 +1,3 @@
+module MotionFacon
+  VERSION = '0.5.0.1'
+end

data/motion-facon.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'motion-facon/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'motion-facon'
+  s.version     = MotionFacon::VERSION
+  s.authors     = ['chuyeow', 'svyatogor']
+  s.email       = ['chuyeow@gmail.com', 'svyatogor@gmail.com']
+  s.homepage    = 'https://github.com/svyatogor/motion-facon'
+  s.summary     = %q{Tiny mocking library.}
+  s.description = %q{Port of facon mocking library to rubymotion.}
+
+  s.rubyforge_project = 'motion-facon'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features,app}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/spec/baconize_spec.rb

@@ -0,0 +1,35 @@
+describe "Facon::Baconize" do
+  extend Facon::SpecHelpers
+
+  before do
+    @mock = Facon::Mock.new('test mock')
+  end
+
+  it "should make the #receive instance method available to Should" do
+    methods = Should.public_instance_methods.collect { |m|  m.to_s }
+    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,183 @@
+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
+
+  it "should pass when receiving a message the expected number of times" do
+    @mock.should_receive(:message).times(3)
+
+    3.times do
+      @mock.message
+    end
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError when receiving a message < expected number of times" do
+    @mock.should_receive(:message).times(3)
+
+    1.times do
+      @mock.message
+    end
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :message with (any args) 3 times, but received it 1 time"
+  end
+
+  it "should raise a MockExpectationError when receiving a message > expected number of times" do
+    @mock.should_receive(:message).times(3)
+
+    5.times do
+      @mock.message
+    end
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :message with (any args) 3 times, but received it 5 times"
+  end
+
+  it "should pass when receiving a message once as expected" do
+    @mock.should.receive(:message).once
+
+    @mock.message
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError when never receiving a message but expecting it once" do
+    @mock.should.receive(:message).once
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :message with (any args) 1 time, but received it 0 times"
+  end
+
+  it "should raise a MockExpectationError when receiving a message more than once but expecting it once" do
+    @mock.should.receive(:message).once
+
+    2.times do
+      @mock.message
+    end
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :message with (any args) 1 time, but received it 2 times"
+  end
+
+  it "should pass when never receiving a message as expected" do
+    @mock.should.receive(:message).never
+
+    verify_mock
+  end
+
+  it "should raise a MockExpectationError when receiving a message but never expecting it" do
+    @mock.should.receive(:message).never
+
+    @mock.message
+
+    lambda { @mock.spec_verify }.should.raise(Facon::MockExpectationError).message.should == "Mock 'test mock' expected :message with (any args) 0 times, but received it 1 time"
+  end
+end

data/spec/mock_spec.rb

@@ -0,0 +1,20 @@
+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/stub_spec.rb

@@ -0,0 +1,125 @@
+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,74 @@
+--- !ruby/object:Gem::Specification
+name: motion-facon
+version: !ruby/object:Gem::Version
+  version: 0.5.0.1
+  prerelease: 
+platform: ruby
+authors:
+- chuyeow
+- svyatogor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-11 00:00:00.000000000 Z
+dependencies: []
+description: Port of facon mocking library to rubymotion.
+email:
+- chuyeow@gmail.com
+- svyatogor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Changelog.txt
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- lib/motion-facon.rb
+- lib/motion-facon/baconize.rb
+- lib/motion-facon/error_generator.rb
+- lib/motion-facon/expectation.rb
+- lib/motion-facon/mock.rb
+- lib/motion-facon/mockable.rb
+- lib/motion-facon/proxy.rb
+- lib/motion-facon/spec_helpers.rb
+- lib/motion-facon/version.rb
+- motion-facon.gemspec
+- resources/Default-568h@2x.png
+- spec/baconize_spec.rb
+- spec/expectation_spec.rb
+- spec/mock_spec.rb
+- spec/stub_spec.rb
+homepage: https://github.com/svyatogor/motion-facon
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: motion-facon
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tiny mocking library.
+test_files:
+- app/app_delegate.rb
+- spec/baconize_spec.rb
+- spec/expectation_spec.rb
+- spec/mock_spec.rb
+- spec/stub_spec.rb