mcmire-rr 1.0.5.rc1

data/Rakefile

@@ -0,0 +1,49 @@
+require "rake"
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Runs the Rspec suite"
+task(:default) do
+  run_suite
+end
+
+desc "Runs the Rspec suite"
+task(:spec) do
+  run_suite
+end
+
+def run_suite
+  dir = File.dirname(__FILE__)
+  system("ruby #{dir}/spec/spec_suite.rb") || raise("Spec Suite failed")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "mcmire-rr"
+    s.summary = "RR (Double Ruby) is a double framework that features a rich " <<
+                "selection of double techniques and a terse syntax. " <<
+                "http://xunitpatterns.com/Test%20Double.html"
+    s.email = "brian@pivotallabs.com"
+    s.homepage = "http://pivotallabs.com"
+    s.description = "RR (Double Ruby) is a double framework that features a rich " <<
+                    "selection of double techniques and a terse syntax. " <<
+                    "http://xunitpatterns.com/Test%20Double.html"
+    s.authors = ["Brian Takita"]
+    s.files = FileList[
+      '[A-Z]*',
+      '*.rb',
+      'lib/**/*.rb',
+      'spec/**/*.rb'
+    ].to_a
+    s.test_files = Dir.glob('spec/*_spec.rb')
+    s.has_rdoc = true
+    s.extra_rdoc_files = [ "README.rdoc", "CHANGES" ]
+    s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+1.0.5.rc1

data/lib/rr.rb

@@ -0,0 +1,101 @@
+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/rspec2"
+require "#{dir}/rr/adapters/test_unit"
+require "#{dir}/rr/adapters/minitest"
+
+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/lib/rr/adapters/minitest.rb

@@ -0,0 +1,31 @@
+module RR
+  module Adapters
+    module MiniTest
+      include RRMethods
+      def self.included(mod)
+        RR.trim_backtrace = true
+        mod.class_eval do
+          unless instance_methods.any? { |method_name| method_name.to_sym == :setup_with_rr }
+            alias_method :setup_without_rr, :setup
+            def setup_with_rr
+              setup_without_rr
+              RR.reset
+            end
+            alias_method :setup, :setup_with_rr
+
+            alias_method :teardown_without_rr, :teardown
+            def teardown_with_rr
+              RR.verify
+              teardown_without_rr
+            end
+            alias_method :teardown, :teardown_with_rr
+          end
+        end
+      end
+
+      def assert_received(subject, &block)
+        block.call(received(subject)).call
+      end
+    end
+  end
+end

data/lib/rr/adapters/rr_methods.rb

@@ -0,0 +1,146 @@
+module RR
+  module Adapters
+    module RRMethods
+      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
+      def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.mock(subject, method_name, &definition_eval_block)
+      end
+
+      def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.stub(subject, method_name, &definition_eval_block)
+      end
+
+      def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
+      end
+
+      def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.proxy(subject, method_name, &definition_eval_block)
+      end
+
+      def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.strong(subject, method_name, &definition_eval_block)
+      end
+
+      def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
+        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
+        double_definition_create.instance_of(subject, method_name, &definition_eval_block)
+      end
+      alias_method :any_instance_of, :instance_of
+      alias_method :all_instances_of, :instance_of
+
+      # Verifies all the DoubleInjection objects have met their
+      # TimesCalledExpectations.
+      def verify
+        RR::Space.instance.verify_doubles
+      end
+
+      # Resets the registered Doubles and ordered Doubles
+      def reset
+        RR::Space.instance.reset
+      end
+
+      # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
+      # to Double#times.
+      #
+      #   mock(object).method_name(anything).times(any_times) {return_value}
+      def any_times
+        TimesCalledMatchers::AnyTimesMatcher.new
+      end
+
+      # Sets up an Anything wildcard ArgumentEqualityExpectation
+      # that succeeds when passed any argument.
+      #   mock(object).method_name(anything) {return_value}
+      #   object.method_name("an arbitrary value") # passes
+      def anything
+        RR::WildcardMatchers::Anything.new
+      end
+
+      # Sets up an IsA wildcard ArgumentEqualityExpectation
+      # that succeeds when passed an argument of a certain type.
+      #   mock(object).method_name(is_a(String)) {return_value}
+      #   object.method_name("A String") # passes
+      def is_a(klass)
+        RR::WildcardMatchers::IsA.new(klass)
+      end
+
+      # Sets up an Numeric wildcard ArgumentEqualityExpectation
+      # that succeeds when passed an argument that is ::Numeric.
+      #   mock(object).method_name(numeric) {return_value}
+      #   object.method_name(99) # passes
+      def numeric
+        RR::WildcardMatchers::Numeric.new
+      end
+
+      # Sets up an Boolean wildcard ArgumentEqualityExpectation
+      # that succeeds when passed an argument that is a ::Boolean.
+      #   mock(object).method_name(boolean) {return_value}
+      #   object.method_name(false) # passes
+      def boolean
+        RR::WildcardMatchers::Boolean.new
+      end
+
+      # Sets up a DuckType wildcard ArgumentEqualityExpectation
+      # that succeeds when the passed argument implements the methods.
+      #   arg = Object.new
+      #   def arg.foo; end
+      #   def arg.bar; end
+      #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
+      #   object.method_name(arg) # passes
+      def duck_type(*args)
+        RR::WildcardMatchers::DuckType.new(*args)
+      end
+
+      # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
+      # that succeeds when the passed argument contains at least those keys
+      # and values of the expectation.
+      #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
+      #   object.method_name({:foo => 1, :bar => 2) # passes
+      def hash_including(expected_hash)
+        RR::WildcardMatchers::HashIncluding.new(expected_hash)
+      end
+
+      # Sets up a Satisfy wildcard ArgumentEqualityExpectation
+      # that succeeds when the passed argument causes the expectation's
+      # proc to return true.
+      #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
+      #   object.method_name(:foo) # passes
+      def satisfy(expectation_proc=nil, &block)
+        expectation_proc ||= block
+        RR::WildcardMatchers::Satisfy.new(expectation_proc)
+      end
+
+      def spy(subject)
+        methods_to_stub = subject.public_methods.map {|method_name| method_name.to_sym} -
+          [:methods, :==, :__send__, :__id__, :object_id, :class]
+        methods_to_stub.each do |method|
+          stub.proxy(subject, method)
+        end
+      end
+
+      def received(subject)
+        RR::SpyVerificationProxy.new(subject)
+      end
+
+      def new_instance_of(*args, &block)
+        RR::DoubleDefinitions::DoubleInjections::NewInstanceOf.call(*args, &block)
+      end
+
+      def any_instance_of(*args, &block)
+        RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
+      end
+
+      instance_methods.each do |name|
+        alias_method "rr_#{name}", name
+      end
+    end
+  end
+  module Extensions
+    InstanceMethods = Adapters::RRMethods
+  end
+end

data/lib/rr/adapters/rspec.rb

@@ -0,0 +1,61 @@
+module RR
+  module Adapters
+    module Rspec
+      def self.included(mod)
+        patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
+        unless patterns.include?(RR::Errors::BACKTRACE_IDENTIFIER)
+          patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+        end
+      end
+
+      include RRMethods
+      def setup_mocks_for_rspec
+        RR.reset
+      end
+      def verify_mocks_for_rspec
+        RR.verify
+      end
+      def teardown_mocks_for_rspec
+        RR.reset
+      end
+
+      def have_received(method = nil)
+        InvocationMatcher.new(method)
+      end
+
+      class InvocationMatcher < SpyVerificationProxy
+        attr_reader :failure_message, :spy_verification_proxy
+ 
+        def initialize(method = nil)
+          @verification = nil
+          @subject = nil
+          method_missing(method) if method
+        end
+
+        def matches?(subject)
+          @verification.subject = subject
+          calls = RR::Space.instance.recorded_calls
+          if error = calls.match_error(@verification)
+            @failure_message = error.message
+            false
+          else
+            true
+          end
+        end
+
+        def nil?
+          false
+        end
+
+        def method_missing(method_name, *args, &block)
+          if @verification
+            @verification.send(method_name, *args)
+          else
+            @verification = super
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/rr/adapters/rspec2.rb

@@ -0,0 +1,22 @@
+module RR
+  module Adapters
+    module RSpec2
+
+      include RRMethods
+
+      def setup_mocks_for_rspec
+        RR.reset
+      end
+      def verify_mocks_for_rspec
+        RR.verify
+      end
+      def teardown_mocks_for_rspec
+        RR.reset
+      end
+
+      def have_received(method = nil)
+        RR::Adapters::Rspec::InvocationMatcher.new(method)
+      end
+    end
+  end
+end

data/lib/rr/adapters/test_unit.rb

@@ -0,0 +1,31 @@
+module RR
+  module Adapters
+    module TestUnit
+      include RRMethods
+      def self.included(mod)
+        RR.trim_backtrace = true
+        mod.class_eval do
+          unless instance_methods.detect {|method_name| method_name.to_sym == :setup_with_rr}
+            alias_method :setup_without_rr, :setup
+            def setup_with_rr
+              setup_without_rr
+              RR.reset
+            end
+            alias_method :setup, :setup_with_rr
+
+            alias_method :teardown_without_rr, :teardown
+            def teardown_with_rr
+              RR.verify
+              teardown_without_rr
+            end
+            alias_method :teardown, :teardown_with_rr
+          end
+        end
+      end
+
+      def assert_received(subject, &block)
+        block.call(received(subject)).call
+      end
+    end
+  end
+end