Who?

• 2001~2004: C
• 2004~2009: ActionScript
• 2005~2008: C++
• 2006~2015: Ruby
• 2007~2015: (learning) Haskell

RubyConf.TW 2010 (Lightning Talk)

• cerealize — Serialize out of the Cerealize Box:
  A drop-in replacement for ActiveRecord's serialize

RubyConf.TW 2013

• 404 — Conference Not Found
  
  

RubyConf.TW 2014

• RubyQC — A conceptual QuickCheck library for Ruby

RubyConf.TW 2015

• Have you seen the Mock Muack yet?

Table of Contents

• Introduction
• When?
• Muack
• Trade-Offs
• Possibilities

Software Testing

• Unit Testing
• Integration Testing
• System Testing
• ...

Test double

A test double is a generic (meta) term used for these objects or procedures.

Test double

A test double is a generic (meta) term buzzword used for these objects or procedures.

Mock object

In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways.

Table of Contents

• Introduction
• When?
• Muack
• Trade-Offs
• Possibilities

When?

• Non-deterministic (e.g. current time or concurrency)
• Difficult to reproduce (e.g. network error or race condition)
• Too slow (e.g. external network
  or slow components which have already been tested)

Non-deterministic

Current time

require 'time'

class Ticket < Struct.new(:time)
  def expired?
    Time.parse(time) < Time.now
  end
end

    Ticket.new('2015-09-11').expired?

Difficult to reproduce

Network error

require 'socket'

sock = TCPSocket.new('t.co', 80)
sock.write("GET / HTTP/1.0\r\nHost: t.co\r\n\r\n")
begin
  IO.select([sock])
  sock.read_nonblock(256)
rescue IO::WaitReadable
  retry # How to test this clause?
end
sock.close

Too slow

Random bytes

data = File.read('/dev/random', 2**20)

require 'socket'
sock = TCPSocket.new('t.co', 80)
sock.write("POST / HTTP/1.0\r\nHost: t.co\r\n\r\n")
sock.write(data)
sock.close

Table of Contents

• Introduction
• When?
• Muack
• Trade-Offs
• Possibilities

Muack

Muack -- A fast, small, yet powerful mocking library.

Inspired by RR, and it's 32x times faster (750s vs 23s)
than RR for running Rib tests.

Why?

Because RR has/had some bugs and it is too complex for me to fix it.

Kernel: Hello!

require 'pork/auto'
require 'muack'

describe Kernel do
  include Muack::API
  before{ Muack.reset  }
  after { Muack.verify }

  would 'puts' do
    mock(self).puts(is_a(String)){ ok }
    puts "Hello!"
  end
end

Non-deterministic

Current time

class Ticket < Struct.new(:time)
  def expired?
    Time.parse(time) < Time.now
  end
end



    Ticket.new('2015-09-11').expired?

Non-deterministic

Current time

class Ticket < Struct.new(:time)
  def expired?
    Time.parse(time) < Time.now
  end
end
describe Ticket do
  would 'not expired?' do
    mock(Time).now{ Time.at(0) }
    Ticket.new('2015-09-11').expired?
  end
end

Non-deterministic

Current time

class Ticket < Struct.new(:time)
  def expired?
    Time.parse(time) < Time.now
  end
end
describe Ticket do
  would 'not expired?' do
    mock(Time).now{ Time.at(0) }
    expect(Ticket.new('2015-09-11')).not.expired?
  end
end

Non-deterministic

Current time

describe Ticket do
  would 'expired?' do
    mock(Time).now{ Time.parse('2015-09-12') }
    expect(Ticket.new('2015-09-11')).expired?
  end

  would 'not expired?' do
    mock(Time).now{ Time.at(0) }
    expect(Ticket.new('2015-09-11')).not.expired?
  end
end

Non-deterministic

Current time (with dependency injection)

class Ticket < Struct.new(:time, :time_class)
  def initialize new_time, new_time_class=Time
    super(new_time, new_time_class)
  end

  def expired?
    Time.parse(time) < time_class.now
  end
end

Non-deterministic

Current time (with dependency injection and simple stubs)

describe Ticket do
  would 'expired?' do
    t = Struct.new(:now).new(Time.parse('2015-09-12'))
    expect(Ticket.new('2015-09-11', t)).expired?
  end

  would 'not expired?' do
    t = Struct.new(:now).new(Time.at(0))
    expect(Ticket.new('2015-09-11', t)).not.expired?
  end
end

What are the terms?

Classification between mocks, fakes, and stubs is highly inconsistent across literature.

Test double

A test double is a generic (meta) term buzzword used for these objects or procedures.

Mock object

In object-oriented programming, mock objects are simulated objects that mimic the behavior of real objects in controlled ways.

Mocks Aren't Stubs

The Difference Between Mocks and Stubs

• Dummy are passed around but never actually used.
• Fake actually have working implementations,
  but usually take some shortcut.
• Stubs provide canned answers to calls made during the test.
• Mocks are pre-programmed with expectations which form a specification of the calls they are expected to receive.

Muack

There are also 4 different kinds of mocks in Muack, which are:

• Mocks
• Stubs
• Spies
• Coats

Non-deterministic

Current time (with dependency injection and simple stubs)

describe Ticket do
  would 'expired?' do
    t = Struct.new(:now).new(Time.parse('2015-09-12'))
    expect(Ticket.new('2015-09-11', t)).expired?
  end

  would 'not expired?' do
    t = Struct.new(:now).new(Time.at(0))
    expect(Ticket.new('2015-09-11', t)).not.expired?
  end
end

Non-deterministic

Current time (with dependency injection and muack stubs)

describe Ticket do
  would 'expired?' do
    t = stub.now{ Time.parse('2015-09-12') }.object
    expect(Ticket.new('2015-09-11', t)).expired?
  end

  would 'not expired?' do
    t = stub.now{ Time.at(0) }.object
    expect(Ticket.new('2015-09-11', t)).not.expired?
  end
end

Non-deterministic

Current time (with dependency injection and muack mocks)

describe Ticket do
  would 'expired?' do
    t = mock.now{ Time.parse('2015-09-12') }.object
    expect(Ticket.new('2015-09-11', t)).expired?
  end

  would 'not expired?' do
    t = mock.now{ Time.at(0) }.object
    expect(Ticket.new('2015-09-11', t)).not.expired?
  end
end

Non-deterministic

Current time (with dependency injection and muack spies)

describe Ticket do
  would 'expired?' do
    t = stub.now{ Time.parse('2015-09-12') }.object
    expect(Ticket.new('2015-09-11', t)).expired?
    spy(t).now


  end
end

Non-deterministic

Current time (with muack spies)

describe Ticket do
  would 'expired?' do
    stub(Time).now{ Time.parse('2015-09-12') }
    expect(Ticket.new('2015-09-11')).expired?
    spy(Time).now
    Muack.verify
    Time.now # => real time here
  end
end

Non-deterministic

Current time (with muack coats)

describe Ticket do
  would 'expired?' do
    coat(Time).now{ Time.parse('2015-09-12') }
    expect(Ticket.new('2015-09-11')).expired?


    Time.now # => real time here
  end
end

Muack Proxy Mode

There are chances that we don't really want to change the underlying implementation for a given method, but we still want to make sure the named method is called, and that's what we're testing for.

Muack Partial Mode

Partial mode is not really a mode, but a combination of using proxy mode and the pattern matching mechanism specialized in stubs.

Muack any_instance_of

Well, sort of a hack to avoid dependency injection yet making it testable.

Muack Modifiers

• times
• with_any_args
• returns (instance_exec mode)
• peek_args (instance_exec mode)
• peek_return (instance_exec mode)

Muack Arguments Verifiers

• anything
• is_a
• matching
• including
• within
• responding_to

Muack Arguments Verifiers

• where
• having
• allowing
• satisfying
• Disjunction (|)
• Conjunction (&)

Muack Caveat

• Mixing mocks and stubs
• any_instance_of shares all calls for a given class

Table of Contents

• Introduction
• When?
• Muack
• Trade-Offs
• Possibilities

Trade-Offs

• Test Isolation
• Dependency Injection

Test Isolation -- without mocks

Advantages:

• More confidence -- we're testing against real stuffs!

Test Isolation -- with mocks

Advantages:

• Test isolation -- one bug one test breaks so easier to track
• Could be much easier to setup

Trade-Offs

• Test Isolation
• Dependency Injection

Without Dependency Injection

Advantages:

• Easier to write for the simplest case
• ↑ Less complexity

With Dependency Injection

Advantages:

• Better module isolation
• ↑ Much easier to mock

Table of Contents

• Introduction
• When?
• Muack
• Trade-Offs
• Possibilities

Auto-mocking with webmock

WebMock.disable_net_connect!

copy :automock do
  before do
    stub(Notify).new_notification.
      with_any_args.peek_args do |*args|
        stub_firebase("notify/#{args.first.fid}")
        args
      end
  end
end

describe Notify do
  paste :automock
end

Truncate only inserted tables

Model = Class.new(Sequel::Model)
copy :model do
  def inserted; @inserted ||= {}; end
  before do
    test = self
    stub(any_instance_of(Model))._insert.
      peek_return(:instance_exec => true) do |r|
        test.inserted[self.class.table_name] = true
        r
      end
  end
  after do
    Model.truncate_all_tables!(inserted.keys)
  end
end

As a development runtime static typing system

Food = Class.new
User = Class.new(Struct.new(:food))

Muack::API.module_eval do
  any_instance_of(User) do |user|
    stub(user).food = is_a(Food) # proxy mode
  end
end

u, f = User.new, Food.new
u.food = f # ok
u.food = 1 # raise Muack::Unexpected

As a mocky patching library

Muack::API.stub(RailsAdmin::Config::Actions).find.
  with_any_args.peek_args do |*args|
    custom_key, bindings = args
    if bindings && bindings[:object] &&
       bindings[:object].id.nil?
      # There's no show page for unsaved records
      [nil, {}]
    else
      args # Bypass arguments
    end
  end

Bibliography

• Test Double