mocha 0.5.6 → 3.0.2

data/Rakefile

@@ -1,149 +1,191 @@
-require 'rubygems'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/testtask'
-require 'rake/contrib/sshpublisher'
-
-module Mocha
-  VERSION = "0.5.6"
+require 'bundler'
+namespace 'rubygems' do
+  Bundler::GemHelper.install_tasks
 end
+require 'bundler/setup'
 
-desc "Run all tests"
-task :default => :test_all
+require 'rake/testtask'
+begin
+  # Only available with `gemfiles/Gemfile.rubocop`
+  require 'rubocop/rake_task'
+rescue LoadError
+  warn "Unable to load 'rubocop/rake_task', but continuing anyway" if $DEBUG
+end
 
-task :test_all => [:test_unit, :test_integration, :test_acceptance]
+desc 'Run all linters and tests'
+task 'default' => ['lint', 'test', 'test:performance']
 
-desc "Run unit tests"
-Rake::TestTask.new(:test_unit) do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/unit/**/*_test.rb']
-  t.verbose = true
-  t.warning = true
+desc 'Run tests'
+task 'test' do
+  if (test_library = ENV['MOCHA_RUN_INTEGRATION_TESTS'])
+    Rake::Task["test:integration:#{test_library}"].invoke
+  else
+    Rake::Task['test:units'].invoke
+    Rake::Task['test:acceptance'].invoke
+  end
 end
 
-desc "Run integration tests"
-Rake::TestTask.new(:test_integration) do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/integration/*_test.rb']
-  t.verbose = true
-  t.warning = true
-end
+namespace 'test' do
+  desc 'Run unit tests'
+  Rake::TestTask.new('units') do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/unit/**/*_test.rb']
+    t.verbose = true
+    t.warning = true
+  end
 
-desc "Run acceptance tests"
-Rake::TestTask.new(:test_acceptance) do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/acceptance/*_test.rb']
-  t.verbose = true
-  t.warning = true
-end
+  desc 'Run acceptance tests'
+  Rake::TestTask.new('acceptance') do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/acceptance/*_test.rb']
+    t.verbose = true
+    t.warning = true
+  end
 
-desc 'Generate RDoc'
-Rake::RDocTask.new do |task|
-  task.main = 'README'
-  task.title = "Mocha #{Mocha::VERSION}"
-  task.rdoc_dir = 'doc'
-  task.template = File.expand_path(File.join(File.dirname(__FILE__), "templates", "html_with_google_analytics"))
-  task.rdoc_files.include('README', 'RELEASE', 'COPYING', 'MIT-LICENSE', 'agiledox.txt', 'lib/mocha/auto_verify.rb', 'lib/mocha/mock.rb', 'lib/mocha/expectation.rb', 'lib/mocha/object.rb', 'lib/mocha/parameter_matchers.rb', 'lib/mocha/parameter_matchers')
-end
-task :rdoc => :examples
+  desc 'Run each test in isolation'
+  task 'isolated' do
+    test_files = FileList['test/unit/**/*_test.rb', 'test/acceptance/*_test.rb']
+    failed_tests = []
 
-desc "Upload RDoc to RubyForge"
-task :publish_rdoc => [:rdoc, :examples] do
-  Rake::SshDirPublisher.new("jamesmead@rubyforge.org", "/var/www/gforge-projects/mocha", "doc").upload
-end
+    test_files.each do |test_file|
+      puts "\n=== Running #{test_file} in isolation ==="
+      system("ruby -Itest -w #{test_file}") || (failed_tests << test_file)
+    end
 
-desc "Generate agiledox-like documentation for tests"
-file 'agiledox.txt' do
-  File.open('agiledox.txt', 'w') do |output|
-    tests = FileList['test/**/*_test.rb']
-    tests.each do |file|
-      m = %r".*/([^/].*)_test.rb".match(file)
-      output << m[1]+" should:\n"
-      test_definitions = File::readlines(file).select {|line| line =~ /.*def test.*/}
-      test_definitions.sort.each do |definition|
-        m = %r"test_(should_)?(.*)".match(definition)
-        output << " - "+m[2].gsub(/_/," ") << "\n"
-      end
+    if failed_tests.any?
+      puts "\n❌ #{failed_tests.size} test file(s) failed:"
+      failed_tests.each { |f| puts "  - #{f}" }
+      exit 1
+    else
+      puts "\n✅ All #{test_files.size} test files passed in isolation!"
     end
   end
-end
 
-desc "Convert example ruby files to syntax-highlighted html"
-task :examples do
-  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "vendor", "coderay-0.7.4.215", "lib"))
-  require 'coderay'
-  mkdir_p 'doc/examples'
-  File.open('doc/examples/coderay.css', 'w') do |output|
-    output << CodeRay::Encoders[:html]::CSS.new.stylesheet
+  namespace 'integration' do
+    desc 'Run Minitest integration tests (intended to be run in its own process)'
+    Rake::TestTask.new('minitest') do |t|
+      t.libs << 'test'
+      t.test_files = FileList['test/integration/minitest_test.rb']
+      t.verbose = true
+      t.warning = true
+    end
+
+    desc 'Run Test::Unit integration tests (intended to be run in its own process)'
+    Rake::TestTask.new('test-unit') do |t|
+      t.libs << 'test'
+      t.test_files = FileList['test/integration/test_unit_test.rb']
+      t.verbose = true
+      t.warning = true
+    end
   end
-  ['mocha', 'stubba', 'misc'].each do |filename|
-    File.open("doc/examples/#{filename}.html", 'w') do |file|
-      file << "<html>"
-      file << "<head>"
-      file << %q(<link rel="stylesheet" media="screen" href="coderay.css" type="text/css">)
-      file << "</head>"
-      file << "<body>"
-      file << CodeRay.scan_file("examples/#{filename}.rb").html.div
-      file << "</body>"
-      file << "</html>"
+
+  # require 'rcov/rcovtask'
+  # Rcov::RcovTask.new('coverage') do |t|
+  #   t.libs << 'test'
+  #   t.test_files = unit_tests + acceptance_tests
+  #   t.verbose = true
+  #   t.warning = true
+  #   t.rcov_opts << '--sort coverage'
+  #   t.rcov_opts << '--xref'
+  # end
+
+  desc 'Run performance tests'
+  task 'performance' do
+    require File.join(File.dirname(__FILE__), 'test', 'acceptance', 'stubba_example_test')
+    require File.join(File.dirname(__FILE__), 'test', 'acceptance', 'mocha_example_test')
+    iterations = 1000
+    puts "\nBenchmarking with #{iterations} iterations..."
+    [MochaExampleTest, StubbaExampleTest].each do |test_case|
+      puts "#{test_case}: #{benchmark_test_case(test_case, iterations)} seconds."
     end
   end
 end
 
-Gem::manage_gems
-
-specification = Gem::Specification.new do |s|
-  s.name   = "mocha"
-  s.summary = "Mocking and stubbing library"
-  s.version = Mocha::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.author = 'James Mead'
-  s.description = <<-EOF
-    Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.
-  EOF
-  s.email = 'mocha-developer@rubyforge.org'
-  s.homepage = 'http://mocha.rubyforge.org'
-  s.rubyforge_project = 'mocha'
-
-  s.has_rdoc = true
-  s.extra_rdoc_files = ['README', 'COPYING']
-  s.rdoc_options << '--title' << 'Mocha' << '--main' << 'README' << '--line-numbers'
-                         
-  s.autorequire = 'mocha'
-  s.add_dependency('rake')
-  s.files = FileList['{lib,test,examples}/**/*.rb', '[A-Z]*'].exclude('TODO').to_a
+desc 'Run linters'
+task 'lint' do
+  if defined?(RuboCop::RakeTask)
+    RuboCop::RakeTask.new
+    Rake::Task['rubocop'].invoke
+  else
+    puts 'RuboCop not available - skipping linting'
+  end
 end
 
-Rake::GemPackageTask.new(specification) do |package|
-   package.need_zip = true
-   package.need_tar = true
+def benchmark_test_case(klass, iterations) # rubocop:disable Metrics/AbcSize
+  require 'benchmark'
+  require 'mocha/detection/minitest'
+
+  if defined?(Minitest)
+    minitest_version = Gem::Version.new(Mocha::Detection::Minitest.version)
+    if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
+      run_method = Gem::Requirement.new('>= 6.0.0').satisfied_by?(minitest_version) ? :run_suite : :run
+      Minitest.seed = 1
+      result = Benchmark.realtime { iterations.times { |_i| klass.public_send(run_method, Minitest::CompositeReporter.new) } }
+      Minitest::Runnable.runnables.delete(klass)
+      result
+    else
+      Minitest::Unit.output = StringIO.new
+      Benchmark.realtime { iterations.times { |_i| Minitest::Unit.new.run([klass]) } }
+    end
+  else
+    load 'test/unit/ui/console/testrunner.rb' unless defined?(Test::Unit::UI::Console::TestRunner)
+    unless @silent_option
+      begin
+        load 'test/unit/ui/console/outputlevel.rb' unless defined?(Test::Unit::UI::Console::OutputLevel::SILENT)
+        @silent_option = { output_level: Test::Unit::UI::Console::OutputLevel::SILENT }
+      rescue LoadError
+        @silent_option = Test::Unit::UI::SILENT
+      end
+    end
+    Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, @silent_option) } }
+  end
 end
+if ENV['MOCHA_GENERATE_DOCS']
+  require 'yard'
 
-task :verify_user do
-  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
-end
+  namespace :docs do
+    desc 'Remove generated documentation'
+    task :clobber do
+      `rm -rf ./docs`
+    end
 
-task :verify_password do
-  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
-end
+    desc 'Generate documentation'
+    YARD::Rake::YardocTask.new(:generate) do |task|
+      task.options = ['--title', "Mocha #{Mocha::VERSION}", '--fail-on-warning']
+    end
+
+    desc 'Ensure custom domain remains in place for docs on GitHub Pages'
+    task :ensure_cname do
+      `git checkout docs/CNAME`
+    end
 
-desc "Publish package files on RubyForge."
-task :publish_packages => [:verify_user, :verify_password, :package] do
-  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "vendor", "meta_project-0.4.15", "lib"))
-  require 'meta_project'
-  require 'rake/contrib/xforge'
-  release_files = FileList[
-    "pkg/mocha-#{Mocha::VERSION}.gem",
-    "pkg/mocha-#{Mocha::VERSION}.tgz",
-    "pkg/mocha-#{Mocha::VERSION}.zip"
-  ]
-
-  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new('mocha')) do |release|
-    release.user_name = ENV['RUBYFORGE_USER']
-    release.password = ENV['RUBYFORGE_PASSWORD']
-    release.files = release_files.to_a
-    release.release_name = "Mocha #{Mocha::VERSION}"
-    release.release_changes = ''
-    release.release_notes = ''
+    desc 'Ensure custom JavaScript files remain in place for docs on GitHub Pages'
+    task :ensure_js do
+      `git checkout docs/js/app.js`
+      `git checkout docs/js/jquery.js`
+    end
+
+    desc 'Check documentation coverage'
+    task :coverage do
+      stats_output = `yard stats --list-undoc`
+      puts stats_output
+
+      match = stats_output.match(/(?<coverage_percentage>\d+\.\d+)% documented/);
+      abort 'Error: Could not determine documentation coverage.' unless match
+
+      coverage_percentage = match[:coverage_percentage].to_f
+      minimum_percentage = 100.0
+
+      if coverage_percentage < minimum_percentage
+        abort "Documentation coverage is #{coverage_percentage}%, which is below the required #{minimum_percentage}%."
+      else
+        puts "Documentation coverage is #{coverage_percentage}%, which is at or above the required #{minimum_percentage}%."
+      end
+    end
   end
+
+  desc 'Prepare documentation for publication on GitHub Pages'
+  task 'docs' => %w[docs:clobber docs:generate docs:ensure_cname docs:ensure_js]
 end
+
+task 'release' => ['default', 'rubygems:release']

data/gemfiles/Gemfile.minitest.latest

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+group :development do
+  gem 'rake'
+  gem 'minitest'
+end

data/gemfiles/Gemfile.rubocop

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+group :development do
+  gem 'rake'
+  gem 'rubocop'
+  gem 'rubocop-rake'
+end

data/gemfiles/Gemfile.test-unit.latest

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+group :development do
+  gem 'rake'
+  gem 'test-unit'
+end

data/lib/mocha/any_instance_method.rb

@@ -1,35 +1,21 @@
-require 'mocha/class_method'
+# frozen_string_literal: true
 
-module Mocha
+require 'mocha/stubbed_method'
 
-  class AnyInstanceMethod < ClassMethod
-  
-    def unstub
-      remove_new_method
-      restore_original_method
-      stubbee.any_instance.reset_mocha
-    end
-    
-    def mock
-      stubbee.any_instance.mocha
-    end
-   
-    def hide_original_method
-      stubbee.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.method_defined?(method)
-    end
+module Mocha
+  class AnyInstanceMethod < StubbedMethod
+    private
 
-    def define_new_method
-      stubbee.class_eval "def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end"
+    def stubbee
+      stubba_object.any_instance
     end
 
-    def remove_new_method
-      stubbee.class_eval "remove_method :#{method}"
+    def stubbee_method(method_name)
+      stubba_object.instance_method(method_name)
     end
 
-    def restore_original_method
-      stubbee.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.method_defined?(hidden_method)
+    def original_method_owner
+      stubba_object
     end
-
   end
-  
-end
+end

data/lib/mocha/any_instance_receiver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mocha
+  class AnyInstanceReceiver
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def mocks
+      klass = @klass
+      mocks = []
+      while klass
+        mocha = klass.any_instance.mocha(instantiate: false)
+        mocks << mocha if mocha
+        klass = klass.superclass
+      end
+      mocks
+    end
+  end
+end

data/lib/mocha/api.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'mocha/ruby_version'
+require 'mocha/parameter_matchers'
+require 'mocha/hooks'
+require 'mocha/mockery'
+require 'mocha/sequence'
+require 'mocha/object_methods'
+require 'mocha/class_methods'
+
+module Mocha
+  # Methods added to +Test::Unit::TestCase+, +Minitest::Unit::TestCase+ or equivalent.
+  # The mock creation methods are {#mock}, {#stub} and {#stub_everything}, all of which return a #{Mock}
+  # which can be further modified by {Mock#responds_like} and {Mock#responds_like_instance_of} methods,
+  # both of which return a {Mock}, too, and can therefore, be chained to the original creation methods.
+  #
+  # {Mock#responds_like} and {Mock#responds_like_instance_of} force the mock to indicate what it is
+  # supposed to be mocking, thus making it a safer verifying mock. They check that the underlying +responder+
+  # will actually respond to the methods being stubbed, throwing a +NoMethodError+ upon invocation otherwise.
+  #
+  # @example Verifying mock using {Mock#responds_like_instance_of}
+  #   class Sheep
+  #     def initialize
+  #       raise "some awkward code we don't want to call"
+  #     end
+  #     def chew(grass); end
+  #   end
+  #
+  #   sheep = mock('sheep').responds_like_instance_of(Sheep)
+  #   sheep.expects(:chew)
+  #   sheep.expects(:foo)
+  #   sheep.respond_to?(:chew) # => true
+  #   sheep.respond_to?(:foo) # => false
+  #   sheep.chew
+  #   sheep.foo # => raises NoMethodError exception
+  module API
+    include ParameterMatchers::Methods
+    include Hooks
+
+    # @private
+    def self.included(_mod)
+      Object.include Mocha::ObjectMethods
+      Class.include Mocha::ClassMethods
+    end
+
+    # @private
+    def self.extended(mod)
+      included(mod)
+    end
+
+    # Builds a new mock object
+    #
+    # @return [Mock] a new mock object
+    #
+    # @overload def mock(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    # @overload def mock(expected_methods_vs_return_values = {})
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
+    # @overload def mock(name, expected_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
+    #
+    # @example Using expected_methods_vs_return_values Hash to setup expectations.
+    #   def test_motor_starts_and_stops
+    #     motor = mock('motor', start: true, stop: true)
+    #     assert motor.start
+    #     assert motor.stop
+    #     # an error will be raised unless both Motor#start and Motor#stop have been called
+    #   end
+    #
+    def mock(*arguments)
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+      expectations = arguments.shift || {}
+      mock = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
+      mock.expects(expectations)
+      mock
+    end
+
+    # Builds a new mock object
+    #
+    # @return [Mock] a new mock object
+    #
+    # @overload def stub(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    # @overload def stub(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    #
+    # @example Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
+    #   def test_motor_starts_and_stops
+    #     motor = stub('motor', start: true, stop: true)
+    #     assert motor.start
+    #     assert motor.stop
+    #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
+    #   end
+    def stub(*arguments)
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+      expectations = arguments.shift || {}
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
+      stub.stubs(expectations)
+      stub
+    end
+
+    # Builds a mock object that accepts calls to any method. By default it will return +nil+ for any method call.
+    #
+    # @return [Mock] a new mock object
+    #
+    # @overload def stub_everything(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    # @overload def stub_everything(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    #
+    # @example Ignore invocations of irrelevant methods.
+    #   def test_motor_stops
+    #     motor = stub_everything('motor', stop: true)
+    #     assert_nil motor.irrelevant_method_1 # => no error raised
+    #     assert_nil motor.irrelevant_method_2 # => no error raised
+    #     assert motor.stop
+    #   end
+    def stub_everything(*arguments)
+      name = arguments.shift if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+      expectations = arguments.shift || {}
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
+      stub.stub_everything
+      stub.stubs(expectations)
+      stub
+    end
+
+    # Builds a new sequence which can be used to constrain the order in which expectations can occur.
+    #
+    # Specify that an expected invocation must occur within a named {Sequence} by calling {Expectation#in_sequence}
+    # on each expectation or by passing a block within which all expectations should be constrained by the {Sequence}.
+    #
+    # @param [String] name name of sequence
+    # @yield optional block within which expectations should be constrained by the sequence
+    # @return [Sequence] a new sequence
+    #
+    # @see Expectation#in_sequence
+    #
+    # @example Ensure methods on egg are invoked in correct order.
+    #   breakfast = sequence('breakfast')
+    #
+    #   egg = mock('egg')
+    #   egg.expects(:crack).in_sequence(breakfast)
+    #   egg.expects(:fry).in_sequence(breakfast)
+    #   egg.expects(:eat).in_sequence(breakfast)
+    #
+    # @example Ensure methods across multiple objects are invoked in correct order.
+    #   sequence = sequence(:task_order)
+    #
+    #   task_one = mock("task_one")
+    #   task_two = mock("task_two")
+    #
+    #   task_one.expects(:execute).in_sequence(sequence)
+    #   task_two.expects(:execute).in_sequence(sequence)
+    #
+    #   task_one.execute
+    #   task_two.execute
+    #
+    # @example Ensure methods on egg are invoked in the correct order using a block.
+    #   egg = mock('egg')
+    #   sequence('breakfast') do
+    #     egg.expects(:crack)
+    #     egg.expects(:fry)
+    #     egg.expects(:eat)
+    #   end
+    def sequence(name)
+      Sequence.new(name).tap do |seq|
+        Mockery.instance.sequences.push(seq)
+        begin
+          yield if block_given?
+        ensure
+          Mockery.instance.sequences.pop
+        end
+      end
+    end
+
+    # Builds a new state machine which can be used to constrain the order in which expectations can occur.
+    #
+    # Specify the initial state of the state machine by using {StateMachine#starts_as}.
+    #
+    # Specify that an expected invocation should change the state of the state machine by using {Expectation#then}.
+    #
+    # Specify that an expected invocation should be constrained to occur within a particular +state+ by using {Expectation#when}.
+    #
+    # A test can contain multiple state machines.
+    #
+    # @param [String] name name of state machine
+    # @return [StateMachine] a new state machine
+    #
+    # @see Expectation#then
+    # @see Expectation#when
+    # @see StateMachine
+    # @example Constrain expected invocations to occur in particular states.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def states(name)
+      Mockery.instance.new_state_machine(name)
+    end
+  end
+end

data/lib/mocha/argument_iterator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ArgumentIterator
+    def initialize(argument)
+      @argument = argument
+    end
+
+    def each(&block)
+      if @argument.is_a?(Hash)
+        @argument.each(&block)
+      else
+        block.call(@argument)
+      end
+    end
+  end
+end

data/lib/mocha/backtrace_filter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mocha
+  class BacktraceFilter
+    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..')) + File::SEPARATOR
+
+    def initialize(lib_directory = LIB_DIRECTORY)
+      @lib_directory = lib_directory
+    end
+
+    def filtered(backtrace)
+      backtrace.reject { |location| File.expand_path(location).start_with?(@lib_directory) }
+    end
+  end
+end