eitoball/README.ja.rdoc

## README.ja.rdoc

      
    Raw
  

              README.ja.rdoc
            
          
RR¶ ↑


RR (Double Ruby、ダブルRuby）は、豊富なダブル化技術と簡潔な文法を備えたテストダブルフレームワークです。

詳細な情報¶ ↑


メーリングリスト¶ ↑


double-ruby-users@rubyforge.org

double-ruby-devel@rubyforge.org


ウェブサイト¶ ↑


rubyforge.org/projects/double-ruby

github.com/btakita/rr


テストダブルとは?¶ ↑


テストダブルとは、他のオブジェクトのテストを簡単にするために本当のオブジェクトを置き換えたものを一般化したものです。テストにおいてスタントのダブルのようなものです。次のものはテストダブルです:

モック

スタブ

フェイク

スパイ

プロキシ


xunitpatterns.com/Test%20Double.html

現在、RRでは、モック、スタブ、プロキシ、そして、スパイを実装しています。フェイクは通常カスタム化されたコードが必要ですので、RRのスコープを超えています。

RRの使い方¶ ↑


test/unit¶ ↑


class Test::Unit::TestCase
  include RR::Adapters::TestUnit
end


rspec¶ ↑


Spec::Runner.configure do |config|
  config.mock_with :rr
  # もしくは、バージョンの非互換性で動作しない場合は
  # config.mock_with RR::Adapters::Rspec
end


単独使用¶ ↑


extend RR::Adapters::RRMethods
mock(object).method_name {:return_value}

object.method_name # :return_value が返ります

RR.verify # ダブルの期待を満たしているかを検証します


RRと他のダブル・モックフレームワークでの文法の違い¶ ↑


簡潔な文法¶ ↑


RRのゴールの一つとして、より判読しやすいダブルを作ることです。これはダブルの宣言をできるだけ実際のメソッド呼び出しのように見えるようにすることによって実現しています。ここではRRと他のモックフレームワークを比較しています:

flexmock(User).should_receive(:find).with('42').and_return(jane) # Flexmock
User.should_receive(:find).with('42').and_return(jane) # Rspec
User.expects(:find).with('42').returns {jane} # Mocha
User.should_receive(:find).with('42') {jane} # Rspecで返値ブロックを使う場合
mock(User).find('42') {jane} # RR


ダブルインジェクション（部分モック)¶ ↑


RRでは「ダブルインジェクション」と知られている手法を利用しています。

my_object = MyClass.new
mock(my_object).hello


これをmochaでモックを作る場合と比較します:

my_mocked_object = mock()
my_mocked_object.expects(:hello)


純粋なモックオブジェクト¶ ↑


モックオブジェクトであるという単一の目的でオブジェクトを利用するなら、空のオブジェクトを作ってそうすることができます。

mock(my_mock_object = Object.new).hello


もしくは、mock! メソッドを使うこともできます。

my_mock_object = mock!.hello.subject # Mocks the #hello method and retrieves that object via the #subject method


shoud_receiveやexpectsメソッドを使わない¶ ↑


RRはメソッドの期待を設定するためにmethod_missingメソッドを使用します。これはshould_receiveやexpectsのようなメソッドを使う必要がないことを意味しています。

mock(my_object).hello # my_objectのhelloメソッドはモックになっています


Mocha:

my_object.expects(:hello) # expectsメソッドがhelloメソッドの期待を設定しています


Rspec mocks:

my_object.should_receive(:hello) # should_receiveがhelloメソッドの期待を設定しています


withメソッドの呼び出しは不必要¶ ↑


RRはmethod_missingを使用するため、ほとんどの場合において、引数の期待を設定するための#withメソッドの使用が不必要にもなっています。

mock(my_object).hello('bob', 'jane')


Mocha:

my_object.expects(:hello).with('bob', 'jane')


Rspec mocks:

my_object.should_receive(:hello).with('bob', 'jane')


返値を設定するためのブロックの使用¶ ↑


RRは返値を設定するためにブロックを使うことをサポートしています。RRには＃returnsメソッドもあります。両方の例は同じです。

mock(my_object).hello('bob', 'jane') {'Hello Bob and Jane'}
mock(my_object).hello('bob', 'jane').returns('Hello Bob and Jane')


Mocha:

my_object.expects(:hello).with('bob', 'jane').returns('Hello Bob and Jane')


Rspec mocks:

my_object.should_receive(:hello).with('bob', 'jane').and_return('Hello Bob and Jane')
my_object.should_receive(:hello).with('bob', 'jane') {'Hello Bob and Jane'} #rspecは返り値のブロックもサポートしています


RRの使用方法¶ ↑


あるオブジェクトのダブルを作成するには次のようなメソッドを使うことができます:

mock もしくは mock!

stub もしくは stub!

dont_allow もしくは dont_allow!

proxy もしくは proxy!

instance_of もしくは instance_of!


これらのメソッドは構成可能です。mock、stub、そして、dont_allowはそれらだけで使うことができて、相互排他的です。proxyとinstance_ofはmockかstubを呼び出してから使う必要があります。proxyとinstance_ofを一緒に使うこともできます。

!（びっくりマーク）が付いているメソッドはダブルの対象のオブジェクトのインスタンスを作成します。

mock¶ ↑


mockはオブジェクトのメソッドを期待と実装で置き換えます。期待とは一定の引数で一定の回数（デフォルトは1回）呼び出されるモックです。メソッドが呼び出される際の返値を設定することができます。

xunitpatterns.com/Mock%20Object.html を参照して下さい。

以下の例では、viewが{:partial => “user_info”}をいう引数で1回#renderのメソッド呼び出しを受け取る期待を設定しています。メソッドが呼び出された場合、“Information”を返します。

view = controller.template
mock(view).render(:partial => "user_info") {"Information"}


次のような方法でモックへ渡される引数をいくつでも許すことができます:

mock(view).render.with_any_args.twice do |*args|
  if args.first == {:partial => "user_info}
    "User Info"
  else
    "Stuff in the view #{args.inspect}"
  end
end

stub¶ ↑


stubはオブジェクトのメソッドを1つの実装で置き換えます。どのstubが実行されるのかを区別をつけるために引数と使うことができます。

xunitpatterns.com/Test%20Stub.html を参照して下さい。

以下の例では、User.find メソッドを‘42’を渡されたとき jane を返して、‘99’を渡されたとき bob を返すようにしています。もし、他の id が User.find へ渡されたとき、例外が送出されます。

jane = User.new
bob = User.new
stub(User).find('42') {jane}
stub(User).find('99') {bob}
stub(User).find do |id|
  raise "Unexpected id #{id.inspect} passed to me"
end


dont_allow は do_not_allow のエイリアス、dont_call は do_not_call のエイリアス¶ ↑


dont_allow はダブルに決して呼ばれない期待を設定します。もし、ダブルが呼び出されると TimesCalledError が送出されます。

dont_allow(User).find('42')
User.find('42') # TimesCalledError 例外が送出されます


mock.proxy¶ ↑


mock.proxy は、オブジェクトのメソッドを期待、実装、を実行置き換えて、そして、実際のメソッドを実行します。また、mock.proxy は、返り値を捕捉して、返り値ブロックへ渡します。

以下の例では、view.render({:partial => “right_navigation”}) が、１度呼び出され、描画された部分テンプレートの実際の内容を返します。view.render({:partial => “user_info”}) への呼び出しは、user_info の部分テンプレートを描画して、その内容をブロックへ送り、変数htmlによって表されます。表明が変数htmlになされて、“Different html” が返ります。

view = controller.template
mock.proxy(view).render(:partial => "right_navigation")
mock.proxy(view).render(:partial => "user_info") do |html|
  html.should include("John Doe")
  "Different html"
end


また、mock.proxy を使って、返り値の期待を設定することができます。次の例では、User.find(‘5’)の呼び出しが、通常のActiveRecordの実装をして、実際の値が渡ります。その値は変数 bobを通してブロックに渡されます。それから、bobにはmock.proxyによって、projects が、最初の3 projects だけを返すように設定します。また、bob は valid? でfalseを返すようにモックします。

mock.proxy(User).find('5') do |bob|
  mock.proxy(bob).projects do |projects|
    projects[0..3]
  end
  mock(bob).valid? {false}
  bob
end


stub.proxy¶ ↑


メソッド呼び出しの返り値を捕捉します。次の例では、呼び出される render partial を確認して、render partialの結果を返します。

view = controller.template
stub.proxy(view).render(:partial => "user_info") do |html|
  html.should include("Joe Smith")
  html
end


instance_of¶ ↑


あるクラスのインスタンスにダブルシナリオをつけます。

mock.instance_of(User).valid? {false}


Spies¶ ↑


（stub、mock、やdont_allowによって）あるオブジェクトとそのメソッドへダブルインジェクションを加えることで、RRは、オブジェクトとメソッドのあらゆるメソッド呼び出しを記録します。それから、記録されたメソッド呼び出しに表明を表すことができます。

test/unit¶ ↑


subject = Object.new
stub(subject).foo
subject.foo(1)
assert_received(subject) {|subject| subject.foo(1)}
assert_received(subject) {|subject| subject.bar} # This fails


rspec¶ ↑


subject = Object.new
stub(subject).foo
subject.foo(1)
subject.should have_received.foo(1)
subject.should have_received.bar # this fails


ブロック文法¶ ↑


ブロック文法には2つのモードがあります。

DoubleDefinitionCreatorProxyを引数とする通常ブロックモード

script = MyScript.new mock(script) do |expect|

expect.system("cd #{RAILS_ENV}") {true}
expect.system("rake foo:bar") {true}
expect.system("rake baz") {true}


end

DoubleDefinitionCreatorProxyは評価されたインスタンスであるinstance_evalモード

script = MyScript.new
mock(script) do
  system("cd #{RAILS_ENV}") {true}
  system("rake foo:bar") {true}
  system("rake baz") {true}
end


明示的なDoubleDefinitionCreatorProxyを引数とするブロック文法¶ ↑


ダブルグラフ¶ ↑


RRはダブルグラフのためのメソッドチェーンのAPIサポートを持っています。例えば、#fooというメソッド呼び出しを受け取り、#barへのメソッド呼び出しから受け取り返り値とするオブジェクトが欲しい場合には、

RRでは、次のように定義できます:

stub(object).foo.stub!.bar {:baz}
object.foo.bar # :baz
# or
stub(object).foo {stub!.bar {:baz}}
object.foo.bar # :baz
# or
bar = stub!.bar {:baz}
stub(object).foo {bar}
object.foo.bar # :baz


引数ワイルドカードマッチャー¶ ↑


anything¶ ↑


mock(object).foobar(1, anything)
object.foobar(1, :my_symbol)


is_a¶ ↑


mock(object).foobar(is_a(Time))
object.foobar(Time.now)


numeric¶ ↑


mock(object).foobar(numeric)
object.foobar(99)


boolean¶ ↑


mock(object).foobar(boolean)
object.foobar(false)


duck_type¶ ↑


mock(object).foobar(duck_type(:walk, :talk))
arg = Object.new
def arg.walk; 'waddle'; end
def arg.talk; 'quack'; end
object.foobar(arg)


Ranges¶ ↑


mock(object).foobar(1..10)
object.foobar(5)


Regexps¶ ↑


mock(object).foobar(/on/)
object.foobar("ruby on rails")


hash_including¶ ↑


mock(object).foobar(hash_including(:red => "#FF0000", :blue => "#0000FF"))
object.foobar({:red => "#FF0000", :blue => "#0000FF", :green => "#00FF00"})


satisfy¶ ↑


mock(object).foobar(satisfy {|arg| arg.length == 2})
object.foobar("xy")


カスタムマッチャーの書き方¶ ↑


Writing a custom argument wildcard matcher is not difficult.  See RR::WildcardMatchers for details. カスタムマッチャーの書くのは難しくありません。詳細はRR::WildcardMatcherを見て下さい。

メソッド呼び出し回数ワイルドカードマッチャー¶ ↑


any_times¶ ↑


mock(object).method_name(anything).times(any_times) {return_value}


Special Thanks To¶ ↑


With any development effort, there are countless people who have contributed to making it possible. We all are standing on the shoulders of giants. If you have directly contributed to RR and I missed you in this list, please let me know and I will add you. Thanks!

Andreas Haller for patches

Aslak Hellesoy for Developing Rspec

Bryan Helmkamp for patches

Christopher Redinger for patches

Dan North for syntax ideas

Dave Astels for some BDD inspiration

Dave Myron for a bug report

David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, syntax ideas, and patches

Daniel Sudol for identifing performance issues with RR

Felix Morio for pairing with me

Gerard Meszaros for his excellent book “xUnit Test Patterns”

James Mead for developing Mocha

Jeff Whitmire for documentation suggestions

Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby

Joe Ferris for patches

Matthew O’Connor for patches and pairing with me

Michael Niessner for patches and pairing with me

Mike Mangino (from Elevated Rails) for patches and pairing with me

Myron Marston for bug reports

Nick Kallen for documentation suggestions, bug reports, and patches

Nathan Sobo for various ideas and inspiration for cleaner and more expressive code

Parker Thompson for pairing with me

Phil Darnowsky for patches

Pivotal Labs for sponsoring RR development

Stephen Baker for Developing Rspec

Tatsuya Ono for patches