mcmire-rr 1.0.5.rc1

data/lib/rr/wildcard_matchers/is_a.rb

@@ -0,0 +1,25 @@
+module RR
+  module WildcardMatchers
+    class IsA
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def wildcard_match?(other)
+        self == other || other.is_a?(klass)
+      end
+
+      def inspect
+        "is_a(#{klass})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.klass == other.klass
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/lib/rr/wildcard_matchers/numeric.rb

@@ -0,0 +1,13 @@
+module RR
+  module WildcardMatchers
+    class Numeric < IsA
+      def initialize
+        @klass = ::Numeric
+      end
+
+      def inspect
+        'numeric'
+      end
+    end
+  end
+end

data/lib/rr/wildcard_matchers/range.rb

@@ -0,0 +1,7 @@
+class Range
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(Numeric)
+    self.include?(other)
+  end
+end

data/lib/rr/wildcard_matchers/regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(String)
+    (other =~ self) ? true : false
+  end
+end

data/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/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/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/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/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/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

data/spec/api/proxy/proxy_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "proxy" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "proxies via inline call" do
+    expected_to_s_value = subject.to_s
+    mock.proxy(subject).to_s
+    subject.to_s.should == expected_to_s_value
+    lambda {subject.to_s}.should raise_error
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    subject.to_s(:foo).should == "Original to_s with arg foo"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "proxy allows ordering" do
+    def subject.to_s(arg)
+      "Original to_s with arg #{arg}"
+    end
+    mock.proxy(subject).to_s(:foo).ordered
+    mock.proxy(subject).to_s(:bar).twice.ordered
+
+    subject.to_s(:foo).should == "Original to_s with arg foo"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    subject.to_s(:bar).should == "Original to_s with arg bar"
+    lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "proxies via block with argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do |c|
+      c.foobar_1(1)
+      c.foobar_2
+    end
+    subject.foobar_1(1).should == :original_value_1
+    lambda {subject.foobar_1(:blah)}.should raise_error
+
+    subject.foobar_2.should == :original_value_2
+    lambda {subject.foobar_2(:blah)}.should raise_error
+  end
+
+  it "proxies via block without argument" do
+    def subject.foobar_1(*args)
+      :original_value_1
+    end
+
+    def subject.foobar_2
+      :original_value_2
+    end
+
+    mock.proxy subject do
+      foobar_1(1)
+      foobar_2
+    end
+    subject.foobar_1(1).should == :original_value_1
+    lambda {subject.foobar_1(:blah)}.should raise_error
+
+    subject.foobar_2.should == :original_value_2
+    lambda {subject.foobar_2(:blah)}.should raise_error
+  end
+end