rr 1.2.1 → 3.0.0

data/spec/suites/rspec_2/unit/expectations/boolean_argument_equality_expectation_spec.rb

@@ -7,20 +7,20 @@ module RR
         attr_reader :expectation
 
         before do
-          @expectation = ArgumentEqualityExpectation.new(boolean)
+          @expectation = ArgumentEqualityExpectation.new([boolean], {})
         end
 
         describe "#wildcard_match?" do
           context "when passed a Boolean" do
             it "returns true" do
-              expect(expectation).to be_wildcard_match(true)
-              expect(expectation).to be_wildcard_match(false)
+              expect(expectation).to be_wildcard_match([true], {})
+              expect(expectation).to be_wildcard_match([false], {})
             end
           end
 
           context "when not passed a Boolean" do
             it "returns false" do
-              expectation.should_not be_wildcard_match(:not_a_boolean)
+              expectation.should_not be_wildcard_match([:not_a_boolean], {})
             end
           end
         end

data/spec/suites/rspec_2/unit/expectations/hash_including_argument_equality_expectation_spec.rb

@@ -11,70 +11,80 @@ module Expectations
 
     describe "#exact_match?" do
       before do
-        @expectation = ArgumentEqualityExpectation.new(hash_including(expected_hash))
+        @expectation = ArgumentEqualityExpectation.new([hash_including(expected_hash)], {})
       end
 
       it "returns true when passed in a HashIncluding matcher with the same hash" do
-        expect(expectation).to be_exact_match(RR::WildcardMatchers::HashIncluding.new(expected_hash))
+        expect(expectation).to be_exact_match([RR::WildcardMatchers::HashIncluding.new(expected_hash)],
+                                              {})
       end
 
       it "returns false when passed in a HashIncluding matcher with a different argument list" do
-        expectation.should_not be_exact_match(RR::WildcardMatchers::HashIncluding.new(:foo => 1))
+        expectation.should_not be_exact_match([RR::WildcardMatchers::HashIncluding.new(:foo => 1)],
+                                              {})
       end
 
       it "returns false otherwise" do
-        expectation.should_not be_exact_match("hello")
-        expectation.should_not be_exact_match(:hello)
-        expectation.should_not be_exact_match(1)
-        expectation.should_not be_exact_match(nil)
-        expectation.should_not be_exact_match(true)
-        expectation.should_not be_exact_match()
+        expectation.should_not be_exact_match(["hello"], {})
+        expectation.should_not be_exact_match([:hello], {})
+        expectation.should_not be_exact_match([1], {})
+        expectation.should_not be_exact_match([nil], {})
+        expectation.should_not be_exact_match([true], {})
+        expectation.should_not be_exact_match([], {})
       end
     end
 
     describe "#wildcard_match?" do
       before do
-        @expectation = ArgumentEqualityExpectation.new(hash_including(expected_hash))
+        @expectation = ArgumentEqualityExpectation.new([hash_including(expected_hash)],
+                                                       {})
       end
 
       it "returns true when hash contains same key/values as the expectation" do
-        expect(expectation).to be_wildcard_match(expected_hash)
+        expect(expectation).to be_wildcard_match([expected_hash], {})
       end
 
       it "returns true when hash contains at least expectation's key/values" do
-        expect(expectation).to be_wildcard_match(expected_hash.merge(:oregon => "Salem"))
+        expect(expectation).to be_wildcard_match([expected_hash.merge(:oregon => "Salem")],
+                                                 {})
       end
 
       it "returns true when passed the same hash, even after the original is modified" do
         original_expected_hash = expected_hash.clone
         expected_hash[:texas] = nil
-        expect(expectation).to be_wildcard_match(original_expected_hash)
+        expect(expectation).to be_wildcard_match([original_expected_hash], {})
       end
 
       it "returns true even if one of the expectation's values is nil" do
-        expectation = ArgumentEqualityExpectation.new(hash_including(:foo => nil))
-        expect(expectation).to be_wildcard_match({:foo => nil})
+        expectation = ArgumentEqualityExpectation.new([hash_including(:foo => nil)],
+                                                      {})
+        expect(expectation).to be_wildcard_match([{:foo => nil}],
+                                                 {})
       end
 
       it "returns false when hash matches only some required key/values" do
-        expectation.should_not be_wildcard_match({:texas => "Austin"})
+        expectation.should_not be_wildcard_match([{:texas => "Austin"}],
+                                                 {})
       end
 
       it "returns false when hash matches all the keys but not all the values" do
-        expectation.should_not be_wildcard_match({:texas => "Austin", :maine => "Portland"})
+        expectation.should_not be_wildcard_match([{:texas => "Austin", :maine => "Portland"}],
+                                                 {})
       end
 
       it "returns false when passed a hash that matches all values but not all keys" do
-        expectation.should_not be_wildcard_match({:texas => "Austin", :georgia => "Augusta"})
+        expectation.should_not be_wildcard_match([{:texas => "Austin", :georgia => "Augusta"}],
+                                                 {})
       end
 
       it "returns true when an exact match" do
-        expect(expectation).to be_wildcard_match(hash_including(expected_hash))
+        expect(expectation).to be_wildcard_match([hash_including(expected_hash)],
+                                                 {})
       end
 
       it "returns false when not passed correct number of arguments" do
-        expectation.should_not be_wildcard_match()
-        expectation.should_not be_wildcard_match(:a, :b)
+        expectation.should_not be_wildcard_match([], {})
+        expectation.should_not be_wildcard_match([:a, :b], {})
       end
     end
   end

data/spec/suites/rspec_2/unit/space_spec.rb

@@ -13,9 +13,10 @@ module RR
         object = Object.new
         method_name = :to_s
         arguments = []
-        space.record_call(object, method_name, arguments, lambda {})
+        keyword_arguments = {}
+        space.record_call(object, method_name, arguments, keyword_arguments, lambda {})
         expect(space.recorded_calls[0]).to eq \
-          RR::RecordedCall.new(object, method_name, arguments, lambda {})
+          RR::RecordedCall.new(object, method_name, arguments, keyword_arguments, lambda {})
       end
     end
 
@@ -202,7 +203,7 @@ module RR
 
       it "should clear the #recorded_calls" do
         object = Object.new
-        space.record_call(object, :to_s, [], nil)
+        space.record_call(object, :to_s, [], {}, nil)
 
         space.reset
         expect(space.recorded_calls).to eq RR::RecordedCalls.new([])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rr
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -10,8 +10,64 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-22 00:00:00.000000000 Z
-dependencies: []
+date: 2021-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: RR is a test double framework that features a rich selection of double
   techniques and a terse syntax.
 email:
@@ -93,10 +149,10 @@ files:
 - lib/rr/integrations/minitest_active_support.rb
 - lib/rr/integrations/rspec/invocation_matcher.rb
 - lib/rr/integrations/rspec_2.rb
+- lib/rr/keyword_arguments.rb
 - lib/rr/method_dispatches/base_method_dispatch.rb
 - lib/rr/method_dispatches/method_dispatch.rb
 - lib/rr/method_dispatches/method_missing_dispatch.rb
-- lib/rr/proc_from_block.rb
 - lib/rr/recorded_call.rb
 - lib/rr/recorded_calls.rb
 - lib/rr/space.rb
@@ -214,7 +270,6 @@ files:
 - spec/suites/rspec_2/unit/injections/double_injection/double_injection_verify_spec.rb
 - spec/suites/rspec_2/unit/integrations/rspec/invocation_matcher_spec.rb
 - spec/suites/rspec_2/unit/integrations/rspec_spec.rb
-- spec/suites/rspec_2/unit/proc_from_block_spec.rb
 - spec/suites/rspec_2/unit/rr_spec.rb
 - spec/suites/rspec_2/unit/space_spec.rb
 - spec/suites/rspec_2/unit/spy_verification_spec.rb
@@ -232,9 +287,6 @@ files:
 - spec/suites/rspec_2/unit/wildcard_matchers/is_a_spec.rb
 - spec/suites/rspec_2/unit/wildcard_matchers/numeric_spec.rb
 - spec/suites/rspec_2/unit/wildcard_matchers/satisfy_spec.rb
-- spec/suites/rspec_2_rails_4/integration/astc_rails_4_spec.rb
-- spec/suites/rspec_2_rails_4/integration/minitest_4_rails_4_spec.rb
-- spec/suites/rspec_2_rails_4/spec_helper.rb
 - spec/support/adapter.rb
 - spec/support/adapter_tests/base.rb
 - spec/support/adapter_tests/minitest.rb
@@ -310,8 +362,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.3.0.dev
 signing_key: 
 specification_version: 4
 summary: RR is a test double framework that features a rich selection of double techniques

data/lib/rr/proc_from_block.rb

@@ -1,11 +0,0 @@
-module RR
-  if RUBY_VERSION =~ /^1.8/
-    class ProcFromBlock < Proc
-      def ==(other)
-        Proc.new(&self) == other
-      end
-    end
-  else
-    ProcFromBlock = Proc
-  end
-end

data/spec/suites/rspec_2/unit/proc_from_block_spec.rb

@@ -1,14 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
-
-module RR
-  describe ProcFromBlock do
-    describe "#==" do
-      it "acts the same as #== on a Proc" do
-        original_proc = lambda {}
-        expect(Proc.new(&original_proc)).to eq original_proc
-
-        expect(ProcFromBlock.new(&original_proc)).to eq original_proc
-      end
-    end
-  end
-end

data/spec/suites/rspec_2_rails_4/integration/astc_rails_4_spec.rb

@@ -1,142 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe 'Integration with straight ActiveSupport::TestCase and Rails 4' do
-  include IntegrationTests::RailsTestUnitLike
-
-  def configure_rails_project_generator(project_generator)
-    super
-    project_generator.configure do |project|
-      project.rails_version = 4
-    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
-          class ActiveSupport::TestCase
-            include RR::Adapters::TestUnit
-          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
-            def test_the_correct_adapters_are_loaded
-              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
-
-  def self.using_rr_with_cucumber_works
-    specify "using RR with Cucumber works" do
-      pending "Cucumber doesn't work with Rails 4 just yet"
-      project_generator = build_rails_project_generator do |project_generator|
-        project_generator.mixin Project::Cucumber
-      end
-      project = project_generator.call
-      result = project.run_command_within("bundle exec cucumber")
-      result.should be_success
-    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
-      [:MiniTest4]
-    end
-
-    including_the_adapter_manually_works
-    using_rr_with_cucumber_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
-      [:MiniTest4, :MiniTest4ActiveSupport]
-    end
-
-    rr_hooks_into_the_test_framework_automatically
-    including_the_adapter_manually_works
-    using_rr_with_cucumber_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
-
-    specify "the database is properly rolled back after an RR error" do
-      project = generate_project do |project|
-        project.add_model_and_migration(:person, :people, :name => :string)
-      end
-      project.add_test_file do |file|
-        file.add_test_case do |test_case|
-          test_case.add_test <<-EOT
-            Person.create!(:name => 'Joe Blow')
-            object = Object.new
-            mock(object).foo
-          EOT
-        end
-      end
-      expect {
-        result = project.run_tests
-        result.should have_errors_or_failures
-      }.to leave_database_table_clear(project, :people)
-    end
-
-    specify "throwing an error in teardown doesn't mess things up" do
-      project = generate_project
-      project.add_test_file do |file|
-        file.add_test_case do |test_case|
-          test_case.add_to_body <<-EOT
-            def teardown
-              raise 'hell'
-            end
-          EOT
-          test_case.add_test("")   # doesn't matter
-        end
-      end
-      result = project.run_tests
-      result.should fail_with_output(/1 error/)
-    end
-  end
-end

data/spec/suites/rspec_2_rails_4/integration/minitest_4_rails_4_spec.rb

@@ -1,149 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe 'Integration with MiniTest 4 and Rails 4' do
-  include IntegrationTests::RailsMinitest
-
-  def configure_rails_project_generator(project_generator)
-    super
-    project_generator.configure do |project|
-      project.rails_version = 4
-    end
-  end
-
-  def configure_project_generator(project_generator)
-    super
-    project_generator.configure do |project|
-      project.minitest_version = 4
-    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
-          class ActiveSupport::TestCase
-            include RR::Adapters::MiniTest
-          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
-            def test_the_correct_adapters_are_loaded
-              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
-
-  def self.using_rr_with_cucumber_works
-    specify "using RR with Cucumber works" do
-      pending "Cucumber doesn't work with Rails 4 just yet"
-      project_generator = build_rails_project_generator do |project_generator|
-        project_generator.mixin Project::Cucumber
-      end
-      project = project_generator.call
-      result = project.run_command_within("bundle exec cucumber")
-      result.should be_success
-    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
-      [:MiniTest4]
-    end
-
-    including_the_adapter_manually_works
-    using_rr_with_cucumber_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
-      [:MiniTest4, :MiniTest4ActiveSupport]
-    end
-
-    rr_hooks_into_the_test_framework_automatically
-    including_the_adapter_manually_works
-    using_rr_with_cucumber_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
-
-    specify "the database is properly rolled back after an RR error" do
-      project = generate_project do |project|
-        project.add_model_and_migration(:person, :people, :name => :string)
-      end
-      project.add_test_file do |file|
-        file.add_test_case do |test_case|
-          test_case.add_test <<-EOT
-            Person.create!(:name => 'Joe Blow')
-            object = Object.new
-            mock(object).foo
-          EOT
-        end
-      end
-      expect {
-        result = project.run_tests
-        result.should have_errors_or_failures
-      }.to leave_database_table_clear(project, :people)
-    end
-
-    specify "throwing an error in teardown doesn't mess things up" do
-      project = generate_project
-      project.add_test_file do |file|
-        file.add_test_case do |test_case|
-          test_case.add_to_body <<-EOT
-            def teardown
-              raise 'hell'
-            end
-          EOT
-          test_case.add_test("")   # doesn't matter
-        end
-      end
-      result = project.run_tests
-      result.should fail_with_output(/1 error/)
-    end
-  end
-end