shoulda-matchers 2.8.0 → 3.0.0.rc1

data/spec/support/unit/matchers/fail_with_message_matcher.rb

@@ -16,7 +16,7 @@ module UnitTests
           @actual = ex.message
         end
 
-        @actual && @actual == expected
+        @actual && @actual == expected.sub(/\n\z/, '')
       end
 
       def failure_message

data/spec/support/unit/rails_application.rb

@@ -1,18 +1,26 @@
+require_relative '../tests/bundle'
 require_relative '../tests/command_runner'
+require_relative '../tests/database'
 require_relative '../tests/filesystem'
-require_relative '../tests/bundle'
+
+require 'yaml'
 
 module UnitTests
   class RailsApplication
     def initialize
       @fs = Tests::Filesystem.new
       @bundle = Tests::Bundle.new
+      @database = Tests::Database.instance
     end
 
     def create
       fs.clean
       generate
-      fs.within_project { install_gems }
+
+      fs.within_project do
+        install_gems
+        remove_unwanted_gems
+      end
     end
 
     def load
@@ -51,7 +59,7 @@ module UnitTests
 
     protected
 
-    attr_reader :fs, :shell, :bundle
+    attr_reader :fs, :shell, :bundle, :database
 
     private
 
@@ -66,6 +74,7 @@ module UnitTests
     def generate
       rails_new
       fix_available_locales_warning
+      write_database_configuration
     end
 
     def rails_new
@@ -75,17 +84,17 @@ module UnitTests
     def fix_available_locales_warning
       # See here for more on this:
       # http://stackoverflow.com/questions/20361428/rails-i18n-validation-deprecation-warning
-
-      filename = 'config/application.rb'
-
-      lines = fs.read(filename).split("\n")
-      lines.insert(-3, <<EOT)
+      fs.transform('config/application.rb') do |lines|
+        lines.insert(-3, <<-EOT)
 if I18n.respond_to?(:enforce_available_locales=)
   I18n.enforce_available_locales = false
 end
-EOT
+        EOT
+      end
+    end
 
-      fs.write(filename, lines.join("\n"))
+    def write_database_configuration
+      YAML.dump(database.config.to_hash, fs.open('config/database.yml', 'w'))
     end
 
     def load_environment
@@ -93,15 +102,22 @@ EOT
     end
 
     def run_migrations
-      ActiveRecord::Migration.verbose = false
-      ActiveRecord::Migrator.migrate(migrations_directory)
+      fs.within_project do
+        run_command! 'bundle exec rake db:drop db:create db:migrate'
+      end
     end
 
     def install_gems
       bundle.install_gems
     end
 
-    private
+    def remove_unwanted_gems
+      bundle.updating do
+        bundle.remove_gem 'debugger'
+        bundle.remove_gem 'byebug'
+        bundle.remove_gem 'web-console'
+      end
+    end
 
     def run_command!(*args)
       Tests::CommandRunner.run!(*args)

data/spec/support/unit/record_validating_confirmation_builder.rb

@@ -34,8 +34,7 @@ module UnitTests
     end
 
     def attribute_that_receives_error
-      Shoulda::Matchers::RailsShim.
-        validates_confirmation_of_error_attribute(self)
+      confirmation_attribute
     end
 
     protected

data/spec/support/unit/shared_examples/set_session_or_flash.rb

@@ -0,0 +1,355 @@
+shared_examples_for 'set session or flash matcher' do
+  context 'without any qualifiers' do
+    it 'produces the right description' do
+      expected_description = "should set any key in #{store_name}"
+      matcher = set_store
+
+      expect(matcher.description).to eq expected_description
+    end
+
+    context 'in the positive' do
+      context 'if the store is not empty' do
+        it 'accepts' do
+          controller = controller_with_store('any key' => 'any value')
+          expect(controller).to set_store
+        end
+      end
+
+      context 'if the store is empty' do
+        it 'rejects' do
+          controller = controller_with_empty_store
+          expect(controller).not_to set_store
+        end
+
+        it 'produces the correct failure message' do
+          controller = controller_with_empty_store
+          expected_message = %<Expected #{controller.class} to set any key in #{store_name}, but it did not>
+
+          expect { expect(controller).to set_store }.
+            to fail_with_message(expected_message)
+        end
+      end
+    end
+
+    context 'in the negative' do
+      context 'if the given key is present in the store' do
+        it 'produces the correct failure message' do
+          controller = controller_with_store('any key' => 'any value')
+          expected_message = %<Expected #{controller.class} not to set any key in #{store_name}, but it did>
+          assertion = proc do
+            expect(controller).not_to set_store
+          end
+
+          expect(&assertion).to fail_with_message(expected_message)
+        end
+      end
+    end
+  end
+
+  context 'with #[]' do
+    it 'produces the right description' do
+      matcher = set_store['the key']
+      expected_description = %<should set #{store_name}["the key"]>
+
+      expect(matcher.description).to eq expected_description
+    end
+
+    context 'in the positive' do
+      context 'if the given key is present in the store' do
+        it 'accepts' do
+          controller = controller_with_store('the key' => 'any value')
+          expect(controller).to set_store['the key']
+        end
+      end
+
+      context 'if the given key is not present in the store' do
+        it 'rejects' do
+          controller = controller_with_empty_store
+          expect(controller).not_to set_store['the key']
+        end
+
+        it 'produces the correct failure message' do
+          controller = controller_with_empty_store
+          expected_message = %<Expected #{controller.class} to set #{store_name}["the key"], but it did not>
+          assertion = proc do
+            expect(controller).to set_store['the key']
+          end
+
+          expect(&assertion).to fail_with_message(expected_message)
+        end
+      end
+    end
+
+    context 'in the negative' do
+      context 'if the given key is present in the store' do
+        it 'produces the correct failure message' do
+          controller = controller_with_store('the key' => 'any value')
+          expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"], but it did>
+          assertion = proc do
+            expect(controller).not_to set_store['the key']
+          end
+
+          expect(&assertion).to fail_with_message(expected_message)
+        end
+      end
+    end
+  end
+
+  context 'with #to' do
+    context 'given a static value' do
+      it 'produces the right description' do
+        matcher = set_store.to('the value')
+        expected_description = %<should set any key in #{store_name} to "the value">
+
+        expect(matcher.description).to eq expected_description
+      end
+
+      context 'in the positive' do
+        context 'if the given value is present in the store' do
+          it 'accepts' do
+            controller = controller_with_store('any key' => 'the value')
+            expect(controller).to set_store.to('the value')
+          end
+
+          it 'accepts given a value of nil' do
+            controller = controller_with_store('any key' => nil)
+            expect(controller).to set_store.to(nil)
+          end
+
+          it 'accepts given a value of false' do
+            controller = controller_with_store('any key' => false)
+            expect(controller).to set_store.to(false)
+          end
+        end
+
+        context 'if the given value is not present in the store' do
+          it 'rejects' do
+            controller = controller_with_empty_store
+            expect(controller).not_to set_store.to('the value')
+          end
+
+          it 'rejects checking for nil' do
+            controller = controller_with_empty_store
+            expect(controller).not_to set_store.to(nil)
+          end
+
+          it 'produces the correct failure message' do
+            controller = controller_with_empty_store
+            expected_message = %<Expected #{controller.class} to set any key in #{store_name} to "the value", but it did not>
+            assertion = proc do
+              expect(controller).to set_store.to('the value')
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+
+      context 'in the negative' do
+        context 'if the given value is present in the store' do
+          it 'produces the correct failure message' do
+            controller = controller_with_store('any key' => 'the value')
+            expected_message = %<Expected #{controller.class} not to set any key in #{store_name} to "the value", but it did>
+            assertion = proc do
+              expect(controller).not_to set_store.to('the value')
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+    end
+
+    context 'given a regexp' do
+      it 'produces the right description' do
+        matcher = set_store.to(/value/)
+        expected_description = %<should set any key in #{store_name} to a value matching /value/>
+
+        expect(matcher.description).to eq expected_description
+      end
+
+      context 'in the positive' do
+        context 'if the given value is present in the store' do
+          it 'accepts' do
+            controller = controller_with_store('any key' => 'the value')
+            expect(controller).to set_store.to(/value/)
+          end
+
+          it 'accepts given a value of nil' do
+            controller = controller_with_store('any key' => nil)
+            expect(controller).to set_store.to(nil)
+          end
+
+          it 'accepts given a value of false' do
+            controller = controller_with_store('any key' => false)
+            expect(controller).to set_store.to(false)
+          end
+        end
+
+        context 'if the given value is not present in the store' do
+          it 'rejects' do
+            controller = controller_with_empty_store
+            expect(controller).not_to set_store.to(/value/)
+          end
+
+          it 'produces the correct failure message' do
+            controller = controller_with_empty_store
+            expected_message = %<Expected #{controller.class} to set any key in #{store_name} to a value matching /value/, but it did not>
+            assertion = proc do
+              expect(controller).to set_store.to(/value/)
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+
+      context 'in the negative' do
+        context 'if the given value is present in the store' do
+          it 'produces the correct failure message' do
+            controller = controller_with_store('any key' => 'the value')
+            expected_message = %<Expected #{controller.class} not to set any key in #{store_name} to a value matching /value/, but it did>
+            assertion = proc do
+              expect(controller).not_to set_store.to(/value/)
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+    end
+  end
+
+  context 'with #[] + #to' do
+    context 'given a static value' do
+      it 'produces the right description' do
+        expected_description = %<should set #{store_name}["the key"] to "the value">
+        matcher = set_store['the key'].to('the value')
+
+        expect(matcher.description).to eq expected_description
+      end
+
+      context 'in the positive' do
+        context 'if the given value is present in the store' do
+          it 'accepts' do
+            controller = controller_with_store('the key' => 'the value')
+            expect(controller).to set_store['the key'].to('the value')
+          end
+        end
+
+        context 'if the given value is not present in the store' do
+          it 'rejects' do
+            controller = controller_with_empty_store
+            expect(controller).not_to set_store['the key'].to('the value')
+          end
+
+          it 'produces the correct failure message' do
+            controller = controller_with_empty_store
+            expected_message = %<Expected #{controller.class} to set #{store_name}["the key"] to "the value", but it did not>
+            assertion = proc do
+              expect(controller).to set_store['the key'].to('the value')
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+
+      context 'in the negative' do
+        context 'if the given value is present in the store' do
+          it 'produces the correct failure message' do
+            controller = controller_with_store('the key' => 'the value')
+            expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"] to "the value", but it did>
+            assertion = proc do
+              expect(controller).not_to set_store['the key'].to('the value')
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+    end
+
+    context 'given a dynamic value' do
+      it 'produces the right description' do
+        context = double('context', method_in_context: 'the value')
+        matcher = set_store['the key'].
+          in_context(context).
+          to { method_in_context }
+        expected_description = %<should set #{store_name}["the key"] to "the value">
+
+        expect(matcher.description).to eq expected_description
+      end
+
+      context 'in the positive' do
+        context 'if the value evaluated in the context is present in the store' do
+          it 'accepts' do
+            controller = controller_with_store('the key' => 'the value')
+            context = double('context', method_in_context: 'the value')
+
+            expect(controller).to set_store['the key'].
+              in_context(context).
+              to { method_in_context }
+          end
+        end
+
+        context 'if the value evaluated in the context is not present in the store' do
+          it 'rejects' do
+            controller = controller_with_empty_store
+            context = double('context', method_in_context: 'the value')
+
+            expect(controller).not_to set_store['the key'].
+              in_context(context).
+              to { method_in_context }
+          end
+
+          it 'produces the correct failure message' do
+            controller = controller_with_empty_store
+            context = double('context', method_in_context: 'the value')
+            expected_message = %<Expected #{controller.class} to set #{store_name}["the key"] to "the value", but it did not>
+            assertion = proc do
+              expect(controller).to set_store['the key'].
+                in_context(context).
+                to { method_in_context }
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+
+      context 'in the negative' do
+        context 'if the value evaluated in the context is present in the store' do
+          it 'produces the correct failure message' do
+            context = double('context', method_in_context: 'the value')
+            controller = controller_with_store('the key' => 'the value')
+            expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"] to "the value", but it did>
+            assertion = proc do
+              expect(controller).not_to set_store['the key'].
+                in_context(context).
+                to { method_in_context }
+            end
+
+            expect(&assertion).to fail_with_message(expected_message)
+          end
+        end
+      end
+    end
+  end
+
+  def controller_with_empty_store
+    build_fake_response
+  end
+
+  def controller_with_store(store_contents)
+    context = self
+
+    build_fake_response do
+      store = context.store_within(self)
+
+      store_contents.each do |key, value|
+        store[key] = value
+      end
+    end
+  end
+end