flexmock 1.3.3 → 2.0.0.rc1

data/test/record_mode_test.rb

@@ -1,158 +0,0 @@
-#!/usr/bin/env ruby
-
-#---
-# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#+++
-
-require 'test/test_setup'
-
-class TestRecordMode < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_recording_mode_works
-    mock = flexmock("mock")
-    mock.should_expect do |recorder|
-      recorder.f { :answer }
-    end
-    assert_equal :answer, mock.f
-  end
-
-  def test_arguments_are_passed_to_recording_mode_block
-    mock = flexmock("mock")
-    mock.should_expect do |recorder|
-      recorder.f(:arg) do |arg|
-        assert_equal :arg, arg
-        :answer
-      end
-    end
-    assert_equal :answer, mock.f(:arg)
-  end
-
-  def test_recording_mode_handles_multiple_returns
-    FlexMock.use("mock") do |mock|
-      mock.should_expect do |r|
-        answers = [1, 2]
-        # HACK: The following lambda is needed in Ruby 1.9 to cause
-        # the answers to be properly bound in the following block.
-        lambda { }
-        r.f { answers.shift }
-      end
-      assert_equal 1, mock.f
-      assert_equal 2, mock.f
-    end
-  end
-
-  def test_recording_mode_does_not_specify_order
-    FlexMock.use("mock") do |mock|
-      mock.should_expect do |r|
-        r.f { 1 }
-        r.g { 2 }
-      end
-      assert_equal 2, mock.g
-      assert_equal 1, mock.f
-    end
-  end
-
-  def test_recording_mode_gets_block_args_too
-    mock = flexmock("mock")
-    mock.should_expect do |r|
-      r.f(1, Proc) { |arg, block|
-        assert_not_nil block
-        block.call
-      }
-    end
-
-    assert_equal :block_result, mock.f(1) { :block_result }
-  end
-
-  def test_recording_mode_should_validate_args_with_equals
-    assert_mock_failure(:deep => true, :line => __LINE__+5) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |r|
-          r.f(1)
-        end
-        mock.f(2)
-      end
-    end
-  end
-
-  def test_recording_mode_should_allow_arg_contraint_validation
-    assert_mock_failure(:deep => true, :line => __LINE__+5) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |r|
-          r.f(1)
-        end
-        mock.f(2)
-      end
-    end
-  end
-
-  def test_recording_mode_should_handle_multiplicity_contraints
-    assert_mock_failure(:line => __LINE__+3) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |r|
-          r.f { :result }.once
-        end
-        mock.f
-        mock.f
-      end
-    end
-  end
-
-  def test_strict_record_mode_requires_exact_argument_matches
-    assert_mock_failure(:deep => true, :line => __LINE__+6) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |rec|
-          rec.should_be_strict
-          rec.f(Integer)
-        end
-        mock.f(3)
-      end
-    end
-  end
-
-  def test_strict_record_mode_requires_exact_ordering
-    assert_mock_failure(:deep => true, :line => __LINE__+8) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |rec|
-          rec.should_be_strict
-          rec.f(1)
-          rec.f(2)
-        end
-        mock.f(2)
-        mock.f(1)
-      end
-    end
-  end
-
-  def test_strict_record_mode_requires_once
-    assert_mock_failure(:deep => true, :line => __LINE__+4) do
-      FlexMock.use("mock") do |mock|
-        mock.should_expect do |rec|
-          rec.should_be_strict
-          rec.f(1)
-        end
-        mock.f(1)
-        mock.f(1)
-      end
-    end
-  end
-
-  def test_strict_record_mode_can_not_fail
-    FlexMock.use("mock") do |mock|
-      mock.should_expect do |rec|
-        rec.should_be_strict
-        rec.f(Integer)
-        rec.f(2)
-      end
-      mock.f(Integer)
-      mock.f(2)
-    end
-  end
-
-end

data/test/redirect_error.rb

@@ -1,16 +0,0 @@
-require 'stringio'
-
-class FlexMock
-  module RedirectError
-    def redirect_error
-      require 'stringio'
-      old_err = $stderr
-      $stderr = StringIO.new
-      yield
-      $stderr.string
-    ensure
-      $stderr = old_err
-    end
-    private :redirect_error
-  end
-end

data/test/rspec_integration/integration_spec.rb

@@ -1,56 +0,0 @@
-#!/usr/bin/env ruby
-
-#---
-# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#+++
-
-if defined?(RSpec)
-  RSpec.configure do |config|
-    config.mock_with :flexmock
-  end
-else
-  Spec::Runner.configure do |config|
-    config.mock_with :flexmock
-  end
-end
-
-describe "FlexMock in a RSpec example" do
-  specify "should be able to create a mock" do
-    m = flexmock()
-  end
-
-  specify "should have an error when a mock is not called" do
-    m = flexmock("Expectation Failured")
-    m.should_receive(:hi).with().once
-    lambda {
-      flexmock_verify
-    }.should raise_error(RSpec::Expectations::ExpectationNotMetError, /\bhi\b.*incorrect.*times/i)
-  end
-
-  specify "should be able to create a stub" do
-    s = "Hello World"
-    flexmock(:base, s).should_receive(:downcase).with().once.and_return("hello WORLD")
-
-    s.downcase.should == "hello WORLD"
-  end
-
-  specify "Should show an example failure" do
-    lambda {
-      1.should == 2
-    }.should raise_error(RSpec::Expectations::ExpectationNotMetError,
-      /expected: 2.*got: 1/m)
-  end
-
-  specify "Should show how mocks are displayed in error messages" do
-    m = flexmock("x")
-    lambda {
-      m.should == 2
-    }.should raise_error(RSpec::Expectations::ExpectationNotMetError, /got: <FlexMock:x>/)
-  end
-
-end

data/test/rspec_integration/spy_example_spec.rb

@@ -1,207 +0,0 @@
-require 'flexmock/rspec'
-
-RSpec.configure do |config|
-  config.mock_with :flexmock
-end
-
-describe "Dog" do
-  class Dog
-    def wags(arg)
-      fail "SHOULD NOT BE CALLED"
-    end
-
-    def barks
-      fail "SHOULD NOT BE CALLED"
-    end
-  end
-
-  let(:dog) { flexmock(:on, Dog) }
-
-  context "single calls with arguments" do
-    before do
-      dog.wags(:tail)
-    end
-
-    it "accepts no with" do
-      dog.should have_received(:wags)
-    end
-
-    it "accepts with restriction" do
-      dog.should have_received(:wags).with(:tail)
-    end
-
-    it "accepts not methods called" do
-      dog.should_not have_received(:bark)
-    end
-
-    it "rejects incorrect with restriction" do
-      should_fail(/^expected wag\(:foot\) to be received by <FlexMock:Dog Mock>/i) do
-        dog.should have_received(:wag).with(:foot)
-      end
-    end
-
-    it "rejects not on correct matcher" do
-      should_fail(/^expected wags\(:tail\) to NOT be received by <FlexMock:Dog Mock>/i) do
-        dog.should_not have_received(:wags).with(:tail)
-      end
-    end
-  end
-
-  context "multiple calls with multiple arguments" do
-    before do
-      dog.wags(:tail)
-      dog.wags(:tail)
-      dog.wags(:tail)
-      dog.wags(:head, :tail)
-      dog.barks
-      dog.barks
-    end
-
-    it "accepts wags(:tail) multiple times" do
-      dog.should have_received(:wags).with(:tail).times(3)
-    end
-
-    it "rejects wags(:tail) wrong times value" do
-      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock>/i) do
-        dog.should have_received(:wags).with(:tail).times(2)
-      end
-    end
-
-    it "detects any_args" do
-      dog.should have_received(:wags).times(4)
-    end
-
-    it "accepts once" do
-      dog.should have_received(:wags).with(:head, :tail).once
-    end
-
-    it "rejects an incorrect once" do
-      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock> once/i) do
-        dog.should have_received(:wags).with(:tail).once
-      end
-    end
-
-    it "accepts twice" do
-      dog.should have_received(:barks).twice
-    end
-
-    it "rejects an incorrect twice" do
-      should_fail(/^expected wags\(:tail\) to be received by <FlexMock:Dog Mock> twice/) do
-        dog.should have_received(:wags).with(:tail).twice
-      end
-    end
-
-    it "accepts never" do
-      dog.should have_received(:jump).never
-    end
-
-    it "rejects an incorrect never" do
-      should_fail(/^expected barks\(\) to be received by <FlexMock:Dog Mock> never/i) do
-        dog.should have_received(:barks).with().never
-      end
-    end
-
-    it "rejects an incorrect never" do
-      dog.should_not have_received(:jump)
-    end
-  end
-
-  context "with additional validations" do
-    it "accepts when correct" do
-      dog.wags(:tail)
-      dog.should have_received(:wags).and { |arg| arg.should == :tail }
-    end
-
-    it "rejects when incorrect" do
-      dog.wags(:tail)
-      should_fail(/expected: :foot.*got: :tail/im) do
-        dog.should have_received(:wags).and { |arg| arg.should == :foot }
-      end
-    end
-
-    it "rejects on all calls" do
-      dog.wags(:foot)
-      dog.wags(:foot)
-      dog.wags(:tail)
-      should_fail(/expected: :foot.*got: :tail/im) do
-        dog.should have_received(:wags).and { |arg| arg.should == :foot }
-      end
-    end
-
-    it "runs the first additional block" do
-      dog.wags(:tail)
-      should_fail(/expected: :foot.*got: :tail/im) do
-        dog.should have_received(:wags).and { |args|
-          args.should == :foot
-        }.and { |args|
-          args.should == :tail
-        }
-      end
-    end
-
-    it "runs the second additional block" do
-      dog.wags(:tail)
-      should_fail(/expected: :foot.*got: :tail/im) do
-        dog.should have_received(:wags).and { |args|
-          args.should == :tail
-        }.and { |args|
-          args.should == :foot
-        }
-      end
-    end
-  end
-
-  context "with ordinal constraints" do
-    it "detects the first call" do
-      dog.wags(:tail)
-      dog.wags(:foot)
-      dog.should have_received(:wags).and { |arg| arg.should == :tail }.on(1)
-    end
-
-    it "detects the second call" do
-      dog.wags(:tail)
-      dog.wags(:foot)
-      dog.should have_received(:wags).and { |arg| arg.should == :foot }.on(2)
-    end
-  end
-
-  context "with blocks" do
-    before do
-      dog.wags { }
-      dog.barks
-    end
-
-    it "accepts wags with a block" do
-      dog.should have_received(:wags).with_a_block
-      dog.should have_received(:wags)
-    end
-
-    it "accepts barks without a block" do
-      dog.should have_received(:barks).without_a_block
-      dog.should have_received(:barks)
-    end
-
-    it "rejects wags without a block" do
-      should_fail(/without a block/) do
-        dog.should have_received(:wags).without_a_block
-      end
-    end
-
-    it "rejects barks with a block" do
-      should_fail(/with a block/) do
-        dog.should have_received(:barks).with_a_block
-      end
-    end
-  end
-
-  def should_fail(message_pattern)
-    failed = false
-    begin
-      yield
-    rescue RSpec::Expectations::ExpectationNotMetError => ex
-      failed = true
-      ex.message.should match(message_pattern)
-    end
-    RSpec::Expectations.fail_with "Expected block to fail with message #{message_pattern.inspect}, no failure detected" unless failed
-  end
-end

data/test/samples_test.rb

@@ -1,283 +0,0 @@
-#!/usr/bin/env ruby
-
-#---
-# Copyright 2003-2013 by Jim Weirich (jim.weirich@gmail.com).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#+++
-
-require 'test/test_setup'
-
-# Sample FlexMock Usage.
-
-class TestSamples < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  # This is a basic example where we setup a mock object to mimic an
-  # IO object.  We know that the +count_lines+ method uses gets, so we
-  # tell the mock object to handle +gets+ by returning successive
-  # elements of an array (just as the real +gets+ returns successive
-  # elements of a file.
-  def test_file_io
-    mock_file = flexmock("file")
-    mock_file.should_receive(:gets).and_return("line 1", "line 2", nil)
-    assert_equal 2, count_lines(mock_file)
-  end
-
-  # Count the number of lines in a file.  Used in the test_file_io
-  # test.
-  def count_lines(file)
-    n = 0
-    while file.gets
-      n += 1
-    end
-    n
-  end
-end
-
-
-class TestUndefined < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_undefined_values
-    m = flexmock("mock")
-    m.should_receive(:divide_by).with(0).
-      and_return_undefined
-    assert_equal FlexMock.undefined, m.divide_by(0)
-  end
-end
-
-
-class TestSimple < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_simple_mock
-    m = flexmock(:pi => 3.1416, :e => 2.71)
-    assert_equal 3.1416, m.pi
-    assert_equal 2.71, m.e
-  end
-end
-
-class TestDog < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_dog_wags
-    tail_mock = flexmock(:wag => :happy)
-    assert_equal :happy, tail_mock.wag
-  end
-end
-
-class Woofer
-end
-
-class Dog
-  def initialize
-    @woofer = Woofer.new
-  end
-  def bark
-    @woofer.woof
-  end
-  def wag
-    :happy
-  end
-end
-
-class TestDogBarking < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  # Setup the tests by mocking the +new+ method of
-  # Woofer and return a mock woofer.
-  def setup
-    @dog = Dog.new
-    flexmock(@dog, :bark => :grrr)
-  end
-
-  def test_dog
-    assert_equal :grrr, @dog.bark   # Mocked Method
-    assert_equal :happy, @dog.wag    # Normal Method
-  end
-end
-
-class TestDogBarkingWithNewInstances < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  # Setup the tests by mocking Woofer to always
-  # return partial mocks.
-  def setup
-    flexmock(Woofer).new_instances.should_receive(:woof => :grrr)
-  end
-
-  def test_dog
-    assert_equal :grrr, Dog.new.bark  # All dog objects
-    assert_equal :grrr, Dog.new.bark  # are mocked.
-  end
-end
-
-class TestDefaults < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def setup
-    @mock_dog = flexmock("Fido")
-    @mock_dog.should_receive(:tail => :a_tail, :bark => "woof").by_default
-  end
-
-  def test_something_where_bark_must_be_called_once
-    @mock_dog.should_receive(:bark => "bow wow").once
-    assert_equal "bow wow", @mock_dog.bark
-    assert_equal :a_tail, @mock_dog.tail
-  end
-end
-
-class TestDemeter < Test::Unit::TestCase
-  include FlexMock::TestCase
-  def test_manual_mocking
-    # Manually mocking a Law of Demeter violation
-    cog = flexmock("cog")
-    cog.should_receive(:turn).once.and_return(:ok)
-    joint = flexmock("gear", :cog => cog)
-    axle = flexmock("axle", :universal_joint => joint)
-    chassis = flexmock("chassis", :axle => axle)
-    car = flexmock("car", :chassis => chassis)
-
-    # test code
-    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
-  end
-
-  def test_demeter
-    car = flexmock("car")
-    car.should_receive( "chassis.axle.universal_joint.cog.turn" => :ok).once
-
-    # Test code
-    assert_equal :ok, car.chassis.axle.universal_joint.cog.turn
-  end
-
-end
-
-class TestDb < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_db
-    db = flexmock('db')
-    db.should_receive(:query).and_return([1,2,3])
-    db.should_receive(:update).with(5).and_return(nil).once
-
-    # test code
-    assert_nil db.update(5)
-  end
-end
-
-
-class TestDb < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_query_and_update
-    db = flexmock('db')
-    db.should_receive(:query).and_return([1,2,3]).ordered
-    db.should_receive(:update).and_return(nil).ordered
-    # test code here
-    assert_raises(assertion_failed_error) do
-      db.update
-      db.query
-    end
-  end
-
-  def test_ordered_queries
-    db = flexmock('db')
-    db.should_receive(:startup).once.ordered
-    db.should_receive(:query).with("CPWR").and_return(12.3).
-      once.ordered(:queries)
-    db.should_receive(:query).with("MSFT").and_return(10.0).
-      once.ordered(:queries)
-    db.should_receive(:query).with(/^....$/).and_return(3.3).
-      at_least.once.ordered(:queries)
-    db.should_receive(:finish).once.ordered
-    # test code here
-    db.startup
-    db.query("CPWR")
-    db.query("MSFT")
-    db.query("asdf")
-    db.finish
-  end
-
-  def test_ordered_queries_in_record_mode
-    db = flexmock('db')
-    db.should_expect do |rec|
-      rec.startup.once.ordered
-      rec.query("CPWR") { 12.3 }.once.ordered(:queries)
-      rec.query("MSFT") { 10.0 }.once.ordered(:queries)
-      rec.query(/^....$/) { 3.3 }.at_least.once.ordered(:queries)
-      rec.finish.once.ordered
-    end
-    # test code here using +db+.
-    db.startup
-    db.query("CPWR")
-    db.query("MSFT")
-    db.query("asdf")
-    db.finish
-  end
-
-  def known_good_way_to_build_xml(builder)
-    builder.html
-  end
-
-  def new_way_to_build_xml(builder)
-    known_good_way_to_build_xml(builder)
-  end
-
-  def test_build_xml
-    builder = flexmock('builder')
-    builder.should_expect do |rec|
-      rec.should_be_strict
-      known_good_way_to_build_xml(rec)  # record the messages
-    end
-    new_way_to_build_xml(builder)       # compare to new way
-  end
-
-end
-
-class TestMoreSamples < Test::Unit::TestCase
-  include FlexMock::TestCase
-
-  def test_multiple_gets
-    file = flexmock('file')
-    file.should_receive(:gets).with_no_args.
-      and_return("line 1\n", "line 2\n")
-    # test code here
-    assert_equal "line 1\n", file.gets
-    assert_equal "line 2\n", file.gets
-  end
-
-  def test_an_important_message
-    m = flexmock('m')
-    m.should_receive(:an_important_message).and_return(1).once
-    m.should_ignore_missing
-    # test code here
-    assert_equal 1, m.an_important_message
-    assert_equal FlexMock.undefined, m.other
-  end
-
-  class QuoteService
-  end
-
-  class Portfolio
-    def initialize
-      @quote_service = QuoteService.new
-    end
-    def value
-      @quote_service.quote
-    end
-  end
-
-  def test_portfolio_value
-    flexmock(QuoteService).new_instances do |m|
-      m.should_receive(:quote).and_return(100)
-    end
-    port = Portfolio.new
-    value = port.value     # Portfolio calls QuoteService.quote
-    assert_equal 100, value
-  end
-
-end