rr 1.1.2 → 1.2.0

data/lib/rr/adapters.rb

@@ -1,34 +0,0 @@
-module RR
-  module Adapters
-    class << self
-      DEPRECATED_ADAPTERS = [
-        :MiniTest,
-        :TestUnit,
-        :RSpec2
-      ]
-
-      def const_missing(adapter_const_name)
-        unless DEPRECATED_ADAPTERS.include?(adapter_const_name)
-          super
-          return
-        end
-
-        show_warning_for(adapter_const_name)
-        RR.autohook
-
-        Module.new
-      end
-
-      private
-
-      def show_warning_for(adapter_const_name)
-        warn <<EOT
---------------------------------------------------------------------------------
-RR deprecation warning: RR now has an autohook system. You don't need to
-`include RR::Adapters::*` in your test framework's base class anymore.
---------------------------------------------------------------------------------
-EOT
-      end
-    end
-  end
-end

data/lib/rr/adapters/rr_methods.rb

@@ -1,142 +0,0 @@
-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
-
-      def any_instance_of(*args, &block)
-        RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
-      end
-
-      # 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
-
-      instance_methods.each do |name|
-        alias_method "rr_#{name}", name
-      end
-    end
-  end
-
-  module Extensions
-    InstanceMethods = Adapters::RRMethods
-  end
-end

data/lib/rr/integrations/rspec_1.rb

@@ -1,46 +0,0 @@
-module RR
-  module Integrations
-    class RSpec1
-      module Mixin
-        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)
-          RSpec::InvocationMatcher.new(method)
-        end
-      end
-
-      def name
-        'RSpec 1'
-      end
-
-      def applies?
-        defined?(::Spec) &&
-        defined?(::Spec::VERSION::STRING) &&
-        ::Spec::VERSION::STRING =~ /^1/
-      end
-
-      def hook
-        ::Spec::Runner.configure do |config|
-          config.mock_with Mixin
-          config.include RR::Adapters::RRMethods
-        end
-        patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
-        unless patterns.include?(RR::Errors::BACKTRACE_IDENTIFIER)
-          patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-        end
-      end
-    end
-
-    RR.register_adapter RSpec1
-  end
-end

data/lib/rr/integrations/test_unit_1.rb

@@ -1,63 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit1
-      module Mixin
-        def assert_received(subject, &block)
-          block.call(received(subject)).call
-        end
-      end
-
-      def name
-        'Test::Unit 1'
-      end
-
-      def applies?
-        defined?(::Test::Unit) &&
-        defined?(::Test::Unit::TestCase) &&
-        !has_test_unit_version? &&
-        !test_unit_just_wraps_minitest?
-      end
-
-      def hook
-        ::Test::Unit::TestCase.class_eval do
-          include RR::Adapters::RRMethods
-          include Mixin
-
-          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
-              RR.trim_backtrace = true
-              RR.overridden_error_class = ::Test::Unit::AssertionFailedError
-            end
-            alias_method :setup, :setup_with_rr
-
-            alias_method :teardown_without_rr, :teardown
-            def teardown_with_rr
-              RR.verify
-            ensure
-              teardown_without_rr
-            end
-            alias_method :teardown, :teardown_with_rr
-          end
-        end
-      end
-
-      def test_unit_just_wraps_minitest?
-        defined?(::Test::Unit::TestCase) &&
-        defined?(::MiniTest::Unit::TestCase) &&
-        ::Test::Unit::TestCase < ::MiniTest::Unit::TestCase
-      end
-
-      def has_test_unit_version?
-        require 'test/unit/version'
-        true
-      rescue LoadError
-        false
-      end
-    end
-
-    RR.register_adapter TestUnit1
-  end
-end

data/lib/rr/integrations/test_unit_2.rb

@@ -1,17 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit2 < TestUnit1
-      def name
-        RR.ruby_18? ? 'Test::Unit 2.4.x' : 'Test::Unit >= 2.5'
-      end
-
-      def applies?
-        defined?(::Test::Unit) &&
-        defined?(::Test::Unit::TestCase) &&
-        has_test_unit_version?
-      end
-    end
-
-    RR.register_adapter TestUnit2
-  end
-end

data/lib/rr/integrations/test_unit_200.rb

@@ -1,27 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit200
-      def initialize
-        @mt4_adapter = RR.adapters_by_name[:MiniTest4]
-        @tu_adapter = RR.adapters_by_name[:TestUnit1]
-      end
-
-      def name
-        'Test::Unit 2.0.0'
-      end
-
-      def applies?
-        @mt4_adapter.applies? &&
-        defined?(::Test::Unit) &&
-        !@tu_adapter.has_test_unit_version? &&
-        @tu_adapter.test_unit_just_wraps_minitest?
-      end
-
-      def hook
-        @mt4_adapter.hook
-      end
-    end
-
-    RR.register_adapter TestUnit200
-  end
-end

data/lib/rr/integrations/test_unit_200_active_support.rb

@@ -1,25 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit200ActiveSupport
-      def initialize
-        @mt4as_adapter = RR.adapters_by_name[:MiniTest4ActiveSupport]
-        @tu200_adapter = RR.adapters_by_name[:TestUnit200]
-      end
-
-      def name
-        "#{@tu200_adapter.name} + ActiveSupport"
-      end
-
-      def applies?
-        @tu200_adapter.applies? && defined?(::ActiveSupport::TestCase)
-      end
-
-      def hook
-        @mt4as_adapter.hook
-      end
-    end
-
-    RR.register_adapter TestUnit200ActiveSupport
-  end
-end
-

data/lib/rr/integrations/test_unit_2_active_support.rb

@@ -1,38 +0,0 @@
-module RR
-  module Integrations
-    class TestUnit2ActiveSupport
-      def initialize
-        @tu2_adapter = RR.adapters_by_name[:TestUnit2]
-      end
-
-      def name
-        "#{@tu2_adapter.name} + ActiveSupport"
-      end
-
-      def applies?
-        @tu2_adapter.applies? &&
-          defined?(::ActiveSupport::TestCase)
-      end
-
-      def hook
-        RR.trim_backtrace = true
-        RR.overridden_error_class = ::Test::Unit::AssertionFailedError
-
-        ::ActiveSupport::TestCase.class_eval do
-          include RR::Adapters::RRMethods
-          include TestUnit1::Mixin
-
-          setup do
-            RR.reset
-          end
-
-          teardown do
-            RR.verify
-          end
-        end
-      end
-    end
-
-    RR.register_adapter TestUnit2ActiveSupport
-  end
-end

data/spec/suites/rspec_1/helper.rb

@@ -1,24 +0,0 @@
-require 'spec/autorun'
-
-require 'rr'
-
-module ExampleMethods
-  def eigen(object)
-    class << object; self; end
-  end
-end
-
-module ExampleGroupMethods
-  def macro(name, &implementation)
-    (class << self; self; end).class_eval do
-      define_method(name, &implementation)
-    end
-  end
-end
-
-Spec::Runner.configure do |c|
-  c.include ExampleMethods
-  c.extend ExampleGroupMethods
-end
-
-Dir[ File.expand_path('../shared/*.rb', __FILE__) ].each {|fn| require fn }

data/spec/suites/rspec_1/integration/rspec_1_spec.rb

@@ -1,93 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe 'Integration with RSpec 1' do
-  include IntegrationTests::RubyRSpec
-
-  def configure_project_generator(project_generator)
-    super
-    project_generator.configure do |project|
-      project.rspec_version = 1
-    end
-  end
-
-  def self.including_the_adapter_manually_works
-    specify "including the adapter manually works" do
-      project = generate_project do |project|
-        project.add_to_prelude <<-EOT
-          Spec::Runner.configure do |c|
-            c.mock_with :rr
-          end
-        EOT
-      end
-      project.add_test_file do |file|
-        file.add_working_test_case_with_adapter_tests do |test_case|
-          test_case.add_to_body <<-EOT
-            it 'loads the correct adapters' do
-              assert_adapters_loaded #{adapters_that_should_be_loaded.inspect}
-            end
-          EOT
-        end
-      end
-      result = project.run_tests
-      result.should be_success
-      result.should_not have_errors_or_failures
-    end
-  end
-
-  def self.rr_hooks_into_the_test_framework_automatically
-    specify "RR hooks into the test framework automatically" do
-      project = generate_project
-      project.add_test_file do |file|
-        file.add_working_test_case
-      end
-      result = project.run_tests
-      result.should be_success
-      result.should_not have_errors_or_failures
-    end
-  end
-
-  context 'when Bundler is autorequiring RR' do
-    def configure_project_generator(project_generator)
-      super
-      project_generator.configure do |project|
-        project.autorequire_gems = true
-      end
-    end
-
-    def adapters_that_should_be_loaded
-      [:RSpec1]
-    end
-
-    including_the_adapter_manually_works
-  end
-
-  context 'when RR is being required manually' do
-    def configure_project_generator(project_generator)
-      super
-      project_generator.configure do |project|
-        project.autorequire_gems = false
-      end
-    end
-
-    def adapters_that_should_be_loaded
-      [:RSpec1]
-    end
-
-    rr_hooks_into_the_test_framework_automatically
-    including_the_adapter_manually_works
-
-    specify "when RR raises an error it raises a failure not an exception" do
-      project = generate_project
-      project.add_test_file do |file|
-        file.add_test_case do |test_case|
-          test_case.add_test <<-EOT
-            object = Object.new
-            mock(object).foo
-          EOT
-        end
-      end
-      result = project.run_tests
-      result.should fail_with_output(/1 failure/)
-    end
-  end
-end