messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/wildcard_matchers/satisfy.rb

@@ -0,0 +1,26 @@
+module RR
+  module WildcardMatchers
+    class Satisfy
+      attr_reader :expectation_proc
+
+      def initialize(expectation_proc)
+        @expectation_proc = expectation_proc
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        !!expectation_proc.call(other)
+      end
+
+      def inspect
+        "satisfy {block}"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expectation_proc == other.expectation_proc
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr/wildcard_matchers.rb

@@ -0,0 +1,158 @@
+=begin rdoc
+
+= Writing your own custom wildcard matchers.
+Writing new wildcard matchers is not too difficult.  If you've ever written
+a custom expectation in RSpec, the implementation is very similar.
+
+As an example, let's say that you want a matcher that will match any number
+divisible by a certain integer.  In use, it might look like this:
+
+  # Will pass if BananaGrabber#bunch_bananas is called with an integer
+  # divisible by 5.
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+To implement this, we need a class RR::WildcardMatchers::DivisibleBy with 
+these instance methods:
+
+* ==(other)
+* eql?(other) (usually aliased to #==)
+* inspect
+* wildcard_match?(other)
+
+and optionally, a sensible initialize method.  Let's look at each of these.
+
+=== .initialize
+
+Most custom wildcard matchers will want to define initialize to store
+some information about just what should be matched.  DivisibleBy#initialize
+might look like this:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def initialize(divisor)
+      @expected_divisor = divisor
+    end
+  end
+
+=== #==(other)
+DivisibleBy#==(other) should return true if other is a wildcard matcher that
+matches the same things as self, so a natural way to write DivisibleBy#== is:
+
+  
+  class RR::WildcardMatchers::DivisibleBy
+    def ==(other)
+      # Ensure that other is actually a DivisibleBy
+      return false unless other.is_a?(self.class)
+
+      # Does other expect to match the same divisor we do?
+      self.expected_divisor = other.expected_divisor
+    end
+  end
+
+Note that this implementation of #== assumes that we've also declared
+  attr_reader :expected_divisor
+
+=== #inspect
+
+Technically we don't have to declare DivisibleBy#inspect, since inspect is
+defined for every object already.  But putting a helpful message in inspect
+will make test failures much clearer, and it only takes about two seconds to
+write it, so let's be nice and do so:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def inspect
+      "integer divisible by #{expected.divisor}"
+    end
+  end
+
+Now if we run the example from above:
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+and it fails, we get a helpful message saying
+
+  bunch_bananas(integer divisible by 5)
+  Called 0 times.
+  Expected 1 times.
+
+=== #wildcard_matches?(other)
+
+wildcard_matches? is the method that actually checks the argument against the
+expectation.  It should return true if other is considered to match,
+false otherwise.  In the case of DivisibleBy, wildcard_matches? reads:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def wildcard_matches?(other)
+      # If other isn't a number, how can it be divisible by anything?
+      return false unless other.is_a?(Numeric)
+
+      # If other is in fact divisible by expected_divisor, then 
+      # other modulo expected_divisor should be 0.
+
+      other % expected_divisor == 0
+    end
+  end
+
+=== A finishing touch: wrapping it neatly
+
+We could stop here if we were willing to resign ourselves to using
+DivisibleBy this way:
+
+  mock(BananaGrabber).bunch_bananas(DivisibleBy.new(5))
+
+But that's less expressive than the original:
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+To be able to use the convenient divisible_by matcher rather than the uglier
+DivisibleBy.new version, re-open the module RR::Adapters::RRMethods and
+define divisible_by there as a simple wrapper around DivisibleBy.new:
+
+  module RR::Adapters::RRMethods
+    def divisible_by(expected_divisor)
+      RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
+    end
+  end
+
+== Recap
+
+Here's all the code for DivisibleBy in one place for easy reference:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def initialize(divisor)
+      @expected_divisor = divisor
+    end
+
+    def ==(other)
+      # Ensure that other is actually a DivisibleBy
+      return false unless other.is_a?(self.class)
+
+      # Does other expect to match the same divisor we do?
+      self.expected_divisor = other.expected_divisor
+    end
+
+    def inspect
+      "integer divisible by #{expected.divisor}"
+    end
+  
+    def wildcard_matches?(other)
+      # If other isn't a number, how can it be divisible by anything?
+      return false unless other.is_a?(Numeric)
+
+      # If other is in fact divisible by expected_divisor, then 
+      # other modulo expected_divisor should be 0.
+
+      other % expected_divisor == 0
+    end
+  end
+  
+  module RR::Adapters::RRMethods
+    def divisible_by(expected_divisor)
+      RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
+    end
+  end
+
+=end
+
+module RR::WildcardMatchers
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/lib/rr.rb

@@ -0,0 +1,99 @@
+dir = File.dirname(__FILE__)
+require 'forwardable'
+
+require "#{dir}/rr/class_instance_method_defined"
+require "#{dir}/rr/blank_slate"
+
+require "#{dir}/rr/errors/rr_error"
+require "#{dir}/rr/errors/subject_does_not_implement_method_error"
+require "#{dir}/rr/errors/subject_has_different_arity_error"
+require "#{dir}/rr/errors/double_definition_error"
+require "#{dir}/rr/errors/double_not_found_error"
+require "#{dir}/rr/errors/double_order_error"
+require "#{dir}/rr/errors/argument_equality_error"
+require "#{dir}/rr/errors/times_called_error"
+require "#{dir}/rr/errors/spy_verification_errors/spy_verification_error"
+require "#{dir}/rr/errors/spy_verification_errors/double_injection_not_found_error"
+require "#{dir}/rr/errors/spy_verification_errors/invocation_count_error"
+
+require "#{dir}/rr/space"
+
+require "#{dir}/rr/double_definitions/strategies/strategy"
+require "#{dir}/rr/double_definitions/strategies/strategy_methods"
+require "#{dir}/rr/double_definitions/strategies/verification/verification_strategy"
+require "#{dir}/rr/double_definitions/strategies/verification/mock"
+require "#{dir}/rr/double_definitions/strategies/verification/stub"
+require "#{dir}/rr/double_definitions/strategies/verification/dont_allow"
+require "#{dir}/rr/double_definitions/strategies/implementation/implementation_strategy"
+require "#{dir}/rr/double_definitions/strategies/implementation/reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/double_injection_strategy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/instance"
+require "#{dir}/rr/double_definitions/strategies/double_injection/any_instance_of"
+require "#{dir}/rr/adapters/rr_methods"
+require "#{dir}/rr/double_definitions/double_injections/instance"
+require "#{dir}/rr/double_definitions/double_injections/any_instance_of"
+require "#{dir}/rr/double_definitions/double_definition"
+
+require "#{dir}/rr/injections/injection"
+require "#{dir}/rr/injections/double_injection"
+require "#{dir}/rr/injections/method_missing_injection"
+require "#{dir}/rr/injections/singleton_method_added_injection"
+require "#{dir}/rr/method_dispatches/base_method_dispatch"
+require "#{dir}/rr/method_dispatches/method_dispatch"
+require "#{dir}/rr/method_dispatches/method_missing_dispatch"
+require "#{dir}/rr/hash_with_object_id_key"
+require "#{dir}/rr/recorded_calls"
+require "#{dir}/rr/proc_from_block"
+
+require "#{dir}/rr/double_definitions/double_definition_create_blank_slate"
+require "#{dir}/rr/double_definitions/double_definition_create"
+require "#{dir}/rr/double_definitions/child_double_definition_create"
+
+require "#{dir}/rr/double"
+require "#{dir}/rr/double_matches"
+
+require "#{dir}/rr/expectations/argument_equality_expectation"
+require "#{dir}/rr/expectations/any_argument_expectation"
+require "#{dir}/rr/expectations/times_called_expectation"
+
+require "#{dir}/rr/wildcard_matchers/anything"
+require "#{dir}/rr/wildcard_matchers/is_a"
+require "#{dir}/rr/wildcard_matchers/numeric"
+require "#{dir}/rr/wildcard_matchers/boolean"
+require "#{dir}/rr/wildcard_matchers/duck_type"
+require "#{dir}/rr/wildcard_matchers/regexp"
+require "#{dir}/rr/wildcard_matchers/range"
+require "#{dir}/rr/wildcard_matchers/satisfy"
+require "#{dir}/rr/wildcard_matchers/hash_including"
+
+require "#{dir}/rr/times_called_matchers/terminal"
+require "#{dir}/rr/times_called_matchers/non_terminal"
+require "#{dir}/rr/times_called_matchers/times_called_matcher"
+require "#{dir}/rr/times_called_matchers/never_matcher"
+require "#{dir}/rr/times_called_matchers/any_times_matcher"
+require "#{dir}/rr/times_called_matchers/integer_matcher"
+require "#{dir}/rr/times_called_matchers/range_matcher"
+require "#{dir}/rr/times_called_matchers/proc_matcher"
+require "#{dir}/rr/times_called_matchers/at_least_matcher"
+require "#{dir}/rr/times_called_matchers/at_most_matcher"
+
+require "#{dir}/rr/spy_verification_proxy"
+require "#{dir}/rr/spy_verification"
+
+require "#{dir}/rr/adapters/rspec"
+require "#{dir}/rr/adapters/test_unit"
+
+module RR
+  class << self
+    include Adapters::RRMethods
+    (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
+      class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          RR::Space.instance.__send__(:#{method_name}, *args, &block)
+        end
+      METHOD
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/scratch.rb

@@ -0,0 +1,118 @@
+o = Object.new
+#p (class << o; self; end).singleton_methods
+#p (class << o; self; end).superclass
+
+klass = Class.new
+p klass
+p klass.superclass
+p (class << klass; self; end).superclass
+p (class << Class; self; end)
+
+p Class.new
+
+##any_instance_of(Person, :id => 111, :to_s => "Joe Smith")
+##
+##any_instance_of(Person) do |person|
+##  person.id {111}
+##  person.to_s {"Joe Smith"}
+##end
+##
+##new_instance_of(Person, :id => 111, :to_s => "Joe Smith")
+##new_instance_of(Person) do |person|
+##  person.id {111}
+##  person.to_s {"Joe Smith"}
+##end
+#
+#class Sut
+#  def existing_method
+#    "existing_method"
+#  end
+#end
+#
+#class Dispatcher
+#  def self.call(subject, method_name, *args, &block)
+#    new(subject, method_name, *args, &block).call
+#  end
+#
+#  attr_reader :method_name
+#  def initialize(subject, method_name, *args, &block)
+#    @subject, @method_name, @args, @block = subject, method_name, args, block
+#  end
+#
+#  def call
+#
+#  end
+#end
+#
+#Sut.class_eval do
+#  alias_method :existing_method_without_rr, :existing_method
+#
+#  def existing_method(*args, &block)
+#    Dispatcher.call(self, :existing_method, *args, &block)
+#  end
+#end
+
+#class SubjectClass
+#  def foo
+#    :foo_original
+#  end
+#
+#  def _dump(arg)
+#    ""
+#  end
+#end
+#subject = SubjectClass.new
+#
+#class << subject
+#  p self.class
+#  class << self
+#    def foobar
+#      :baz
+#    end
+#  end
+#  p foobar
+#end
+#
+#Foo = Module.new do
+#  def foo
+#    :foo_module
+#  end
+#end
+#Bar = Module.new do
+#  def foo
+#    :bar_module
+#  end
+#end
+##module Foo
+##  def foo
+##  end
+##end
+#
+#subject.extend Foo
+#end
+#p subject.foo
+#p Marshal.dump(subject)
+
+
+class Super
+
+end
+class Sub < Super
+
+end
+
+def Super.foo
+  :bar
+end
+
+def Sub.foo
+  super
+end
+
+s = Super.new
+p s.object_id
+p (class << s; self; end).object_id
+p s.class
+#subject.extend Bar
+#def subject.foo
+#  :singleton_foo

data/spec/ruby/1.9.1/gems/rr-1.0.2/spec/api/any_instance_of/all_instances_of_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "all_instances_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    subject_class = Class.new
+    subject = subject_class.new
+    all_instances_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
+    end
+    subject.to_s.should == "Subject is stubbed"
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/spec/api/any_instance_of/any_instance_of_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "any_instance_of" do
+  context "when passed a block" do
+    it "applies to instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      class_called = false
+      any_instance_of(subject_class) do |o|
+        stub(o).to_s {"Subject is stubbed"}
+        stub.proxy(o).class {|klass| class_called = true; klass}
+        stub(o).foobar {:baz}
+      end
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.class.should == subject_class
+      class_called.should == true
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      class_called = false
+      subject.class.should == subject_class
+      class_called.should == false
+      subject.should_not respond_to(:baz)
+    end
+  end
+
+  context "when passed a Hash" do
+    it "stubs methods (key) with the value on instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      subject.should_not respond_to(:baz)
+
+      any_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      subject.should_not respond_to(:baz)
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/spec/api/any_instance_of/instance_of_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "instance_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    subject_class = Class.new
+    subject = subject_class.new
+    instance_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
+    end
+    subject.to_s.should == "Subject is stubbed"
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/spec/api/dont_allow/dont_allow_after_stub_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "dont_allow called after stub" do
+  context "when the subject method is called" do
+    it "raises a TimesCalledError" do
+      subject = Object.new
+      stub(subject).foobar
+      dont_allow(subject).foobar
+      lambda do
+        subject.foobar
+      end.should raise_error(RR::Errors::TimesCalledError)
+    end
+  end
+end

data/spec/ruby/1.9.1/gems/rr-1.0.2/spec/api/mock/mock_spec.rb

@@ -0,0 +1,193 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "mock" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "mocks via inline call" do
+    mock(subject).to_s {"a value"}
+    subject.to_s.should == "a value"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      mock(subject).to_s {"value 1"}.ordered
+      mock(subject).to_s {"value 2"}.twice
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 2"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      proxy.methods.should =~ proxy_target.methods
+
+      mock(proxy).foobar {:new_foobar}
+      proxy.foobar.should == :new_foobar
+    end
+  end
+
+  it 'allows terse chaining' do
+    mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
+    subject.first(1).second(2).third(3).should == 4
+  end
+
+  it 'allows chaining with proxy' do
+    find_return_value = Object.new
+    def find_return_value.child
+      :the_child
+    end
+    (class << subject; self; end).class_eval do
+      define_method(:find) do |id|
+        id == '1' ? find_return_value : raise(ArgumentError)
+      end
+    end
+
+    mock.proxy(subject).find('1').mock.proxy!.child
+    subject.find('1').child.should == :the_child
+  end
+
+  it 'allows branched chaining' do
+    mock(subject).first do
+      mock! do |expect|
+        expect.branch1 {mock!.branch11 {11}}
+        expect.branch2 {mock!.branch22 {22}}
+      end
+    end
+    o = subject.first
+    o.branch1.branch11.should == 11
+    o.branch2.branch22.should == 22
+  end
+
+  it 'allows chained ordering' do
+    mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
+    subject.to_s.should == "value 1"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 3"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "mocks via block with argument" do
+    mock subject do |c|
+      c.to_s {"a value"}
+      c.to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "mocks via block without argument" do
+    mock subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "has wildcard matchers" do
+    mock(subject).foobar(
+      is_a(String),
+      anything,
+      numeric,
+      boolean,
+      duck_type(:to_s),
+      /abc/
+    ) {"value 1"}.twice
+    subject.foobar(
+      'hello',
+      Object.new,
+      99,
+      false,
+      "My String",
+      "Tabcola"
+    ).should == "value 1"
+    lambda do
+      subject.foobar(:failure)
+    end.should raise_error( RR::Errors::DoubleNotFoundError )
+  end
+
+  it "mocks methods without letters" do
+    mock(subject, :==).with(55)
+
+    subject == 55
+    lambda do
+      subject == 99
+    end.should raise_error(RR::Errors::DoubleNotFoundError)
+  end
+
+  it "expects a method call to a mock via another mock's block yield only once" do
+    cage = Object.new
+    cat = Object.new
+    mock(cat).miau    # should be expected to be called only once
+    mock(cage).find_cat.yields(cat)
+    mock(cage).cats
+    cage.find_cat { |c| c.miau }
+    cage.cats
+  end
+
+  describe "on class method" do
+    class SampleClass1
+      def self.hello; "hello!"; end
+    end
+
+    class SampleClass2 < SampleClass1; end
+
+    it "can mock" do
+      mock(SampleClass1).hello { "hola!" }
+
+      SampleClass1.hello.should == "hola!"
+    end
+
+    it "does not override subclasses" do
+      mock(SampleClass1).hello { "hi!" }
+
+      SampleClass2.hello.should == "hello!"
+    end
+
+    it "should not get affected from a previous example" do
+      SampleClass2.hello.should == "hello!"
+    end
+
+  end
+end