redinger-rr 0.10.3

data/lib/rr/wildcard_matchers/boolean.rb

@@ -0,0 +1,23 @@
+module RR
+  module WildcardMatchers
+    class Boolean
+      def wildcard_match?(other)
+        self == other || is_a_boolean?(other)
+      end
+
+      def ==(other)
+        other.is_a?(self.class)
+      end
+      alias_method :eql?, :==
+
+      def inspect
+        'boolean'
+      end
+
+      protected
+      def is_a_boolean?(subject)
+        subject.is_a?(TrueClass) || subject.is_a?(FalseClass)
+      end
+    end
+  end
+end

data/lib/rr/wildcard_matchers/duck_type.rb

@@ -0,0 +1,32 @@
+module RR
+  module WildcardMatchers
+    class DuckType
+      attr_accessor :required_methods
+
+      def initialize(*required_methods)
+        @required_methods = required_methods
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        required_methods.each do |m|
+          return false unless other.respond_to?(m)
+        end
+        return true
+      end
+
+      def inspect
+        formatted_required_methods = required_methods.collect do |method_name|
+          method_name.inspect
+        end.join(', ')
+        "duck_type(#{formatted_required_methods})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.required_methods == other.required_methods
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/lib/rr/wildcard_matchers/hash_including.rb

@@ -0,0 +1,29 @@
+module RR
+  module WildcardMatchers
+    class HashIncluding
+      attr_reader :expected_hash
+
+      def initialize(expected_hash)
+        @expected_hash = expected_hash.clone
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        expected_hash.each_pair do |key, value|
+          return false unless other.has_key?(key) && other[key] == expected_hash[key]
+        end
+        return true
+      end
+
+      def inspect
+        "hash_including(#{expected_hash.inspect})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expected_hash == other.expected_hash
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

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/core_spec_suite.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+require "spec"
+
+class CoreExampleSuite
+  def run
+    files = Dir["#{File.dirname(__FILE__)}/**/*_spec.rb"]
+    files.delete_if {|file| file.include?('rspec/')}
+    files.delete_if {|file| file.include?('test_unit/')}
+    puts "Running Rspec Example Suite"
+    files.each do |file|
+      require file
+#      puts "require '#{file}'"
+    end
+  end
+end
+
+if $0 == __FILE__
+  CoreExampleSuite.new.run
+end

data/spec/environment_fixture_setup.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+require "spec"
+require "spec/autorun"
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+require "rr"
+require "pp"

data/spec/high_level_spec.rb

@@ -0,0 +1,398 @@
+require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+
+class HighLevelSpec
+  attr_reader :initialize_arguments
+
+  def initialize(*args)
+    @initialize_arguments = args
+    yield if block_given?
+    method_run_in_initialize
+  end
+
+  def method_run_in_initialize
+    
+  end
+end
+
+describe "RR" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  describe "mock" do
+    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
+
+    it "allows ordering" 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
+
+    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) == 55
+
+      subject == 55
+      lambda do
+        subject == 99
+      end.should raise_error(RR::Errors::DoubleNotFoundError)
+    end
+  end
+
+  describe "proxy" do
+    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
+
+  describe "stub" do
+    it "stubs via inline call" do
+      stub(subject).to_s {"a value"}
+      subject.to_s.should == "a value"
+    end
+
+    it "allows ordering" do
+      stub(subject).to_s {"value 1"}.once.ordered
+      stub(subject).to_s {"value 2"}.once.ordered
+
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+    end
+
+    it "stubs via block with argument" do
+      stub subject do |d|
+        d.to_s {"a value"}
+        d.to_sym {:crazy}
+      end
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
+    end
+
+    it "stubs via block without argument" do
+      stub subject do
+        to_s {"a value"}
+        to_sym {:crazy}
+      end
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
+    end
+
+    it "stubs instance_of" do
+      stub.instance_of(HighLevelSpec) do |o|
+        o.to_s {"High Level Spec"}
+      end
+      HighLevelSpec.new.to_s.should == "High Level Spec"
+    end
+
+    it "stubs methods without letters" do
+      stub(subject).__send__(:==) {:equality}
+      (subject == 55).should == :equality
+    end
+
+    it "stubs methods invoked in #initialize while passing along the #initialize arg" do
+      method_run_in_initialize_stubbed = false
+      stub.instance_of(HighLevelSpec) do |o|
+        o.method_run_in_initialize {method_run_in_initialize_stubbed = true}
+      end
+      HighLevelSpec.new
+      method_run_in_initialize_stubbed.should be_true
+    end
+
+    it "passed the arguments and block passed to #initialize" do
+      block_called = false
+      stub.instance_of(HighLevelSpec) do |o|
+        o.method_run_in_initialize
+      end
+      instance = HighLevelSpec.new(1, 2) {block_called = true}
+      instance.initialize_arguments.should == [1, 2]
+      block_called.should be_true
+    end
+  end
+
+  describe "RR recorded_calls" do
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      subject.pig_rabbit("bacon", "bunny meat")
+      #subject.should have_received.pig_rabitt("bacon", "bunny meat")
+      received(subject).pig_rabbit("bacon", "bunny meat").call
+    end
+    
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      lambda do
+        received(subject).pig_rabbit("bacon", "bunny meat").call
+      end.should raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
+    end
+  end
+  
+  class StrongTestObject
+    def method_with_no_arguments
+    end
+
+    def method_with_one_argument(string)
+    end
+
+    def method_with_two_arguments(string, integer)
+    end
+
+    def method_with_three_arguments_including_varargs(string, integer, *args)
+    end
+
+    def method_with_varargs(*args)
+    end
+  end
+
+  describe "strong" do
+    context "when the method does not exist" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).something
+        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+
+    context "when the method exists with no arguments" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_no_arguments
+      end
+    end
+
+    context "when the method has a different arity" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).method_with_one_argument
+        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+      end
+    end
+
+    context "when the method has accepts a variable number of arguments" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_varargs
+      end
+    end
+
+    context "when the method does not provide the required parameters before varargs" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs
+        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+      end
+    end
+
+    context "when the minimum number of parameters are provided" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs("one", 2)
+      end
+    end
+
+    context "when using instance_of and the method does not exist" do
+      it "raises an exception" do
+        lambda do
+          strong.stub.instance_of(StrongTestObject).something
+          StrongTestObject.new
+        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+
+    context "when using instance_of and the method does exist" do
+      it "does not raise an exception" do
+        strong.stub.instance_of(StrongTestObject).method_with_no_arguments
+      end
+    end
+  end
+
+  describe "spy" do
+    it "should record all method invocations" do
+      subject = Object.new
+      def subject.something
+      end
+
+      def subject.something_else
+      end
+
+      spy(subject)
+
+      subject.something
+      subject.something_else
+      subject.to_s
+
+      received(subject).something.call
+      received(subject).something_else.call
+      received(subject).to_s.call
+    end
+  end
+end