shoulda-matchers 2.7.0 → 2.8.0.rc1

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

@@ -0,0 +1,50 @@
+module UnitTests
+  module Matchers
+    extend RSpec::Matchers::DSL
+
+    matcher :fail_with_message do |expected|
+      def supports_block_expectations?
+        true
+      end
+
+      match do |block|
+        @actual = nil
+
+        begin
+          block.call
+        rescue RSpec::Expectations::ExpectationNotMetError => ex
+          @actual = ex.message
+        end
+
+        @actual && @actual == expected
+      end
+
+      def failure_message
+        msg = "Expectation should have failed with message '#{expected}'"
+
+        if @actual
+          msg << ",\nactually failed with '#{@actual}'"
+        else
+          msg << ", but did not fail."
+        end
+
+        msg
+      end
+
+      def failure_message_for_should
+        failure_message
+      end
+
+      def failure_message_when_negated
+        msg  = "Expectation should not have failed with message '#{expected}'"
+        msg << ", but did."
+
+        msg
+      end
+
+      def failure_message_for_should_not
+        failure_message_when_negated
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module UnitTests
+  module Matchers
+    def print_warning_including(expected_warning)
+      PrintWarningIncludingMatcher.new(expected_warning)
+    end
+
+    class PrintWarningIncludingMatcher
+      def initialize(expected_warning)
+        @expected_warning = collapse_whitespace(expected_warning)
+      end
+
+      def matches?(block)
+        @captured_stderr = collapse_whitespace(capture(:stderr, &block))
+        captured_stderr.include?(expected_warning)
+      end
+
+      def failure_message
+        "Expected block to #{expectation}\nbut actually printed#{actual_warning}"
+      end
+      alias_method :failure_message_for_should, :failure_message
+
+      def failure_message_when_negated
+        "Expected block not to #{expectation}, but it did."
+      end
+      alias_method :failure_message_for_should_not,
+        :failure_message_when_negated
+
+      def description
+        "should #{expectation}"
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      protected
+
+      attr_reader :expected_warning, :captured_stderr
+
+      private
+
+      def expectation
+        "print a warning including:\n  #{expected_warning}"
+      end
+
+      def actual_warning
+        if captured_stderr.empty?
+          " nothing."
+        else
+          ":\n  #{captured_stderr}"
+        end
+      end
+
+      def collapse_whitespace(string)
+        string.gsub(/\n+/, ' ').squeeze(' ')
+      end
+    end
+  end
+end

data/spec/support/unit/rails_application.rb

@@ -0,0 +1,110 @@
+require_relative '../tests/command_runner'
+require_relative '../tests/filesystem'
+require_relative '../tests/bundle'
+
+module UnitTests
+  class RailsApplication
+    def initialize
+      @fs = Tests::Filesystem.new
+      @bundle = Tests::Bundle.new
+    end
+
+    def create
+      fs.clean
+      generate
+      fs.within_project { install_gems }
+    end
+
+    def load
+      load_environment
+      run_migrations
+    end
+
+    def gemfile_path
+      fs.find('Gemfile')
+    end
+
+    def environment_file_path
+      fs.find_in_project('config/environment')
+    end
+
+    def temp_views_directory
+      fs.find_in_project('tmp/views')
+    end
+
+    def create_temp_view(path, contents)
+      full_path = temp_view_path_for(path)
+      full_path.dirname.mkpath
+      full_path.open('w') { |f| f.write(contents) }
+    end
+
+    def delete_temp_views
+      if temp_views_directory.exist?
+        temp_views_directory.rmtree
+      end
+    end
+
+    def draw_routes(&block)
+      Rails.application.routes.draw(&block)
+      Rails.application.routes
+    end
+
+    protected
+
+    attr_reader :fs, :shell, :bundle
+
+    private
+
+    def migrations_directory
+      fs.find_in_project('db/migrate')
+    end
+
+    def temp_view_path_for(path)
+      temp_views_directory.join(path)
+    end
+
+    def generate
+      rails_new
+      fix_available_locales_warning
+    end
+
+    def rails_new
+      run_command! %W(rails new #{fs.project_directory} --skip-bundle)
+    end
+
+    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)
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = false
+end
+EOT
+
+      fs.write(filename, lines.join("\n"))
+    end
+
+    def load_environment
+      require environment_file_path
+    end
+
+    def run_migrations
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Migrator.migrate(migrations_directory)
+    end
+
+    def install_gems
+      bundle.install_gems
+    end
+
+    private
+
+    def run_command!(*args)
+      Tests::CommandRunner.run!(*args)
+    end
+  end
+end

data/spec/support/unit/record_builder_with_i18n_validation_message.rb

@@ -0,0 +1,69 @@
+require 'delegate'
+
+module UnitTests
+  class RecordBuilderWithI18nValidationMessage < SimpleDelegator
+    def initialize(builder, options = {})
+      super(builder)
+      @options = default_options.merge(options)
+      builder.message = validation_message_key
+    end
+
+    def validation_message_key
+      options[:validation_message_key]
+    end
+
+    protected
+
+    attr_reader :builder, :options
+
+    private
+
+    def model
+      @_model ||= super.tap do |model|
+        stub_validation_messages
+      end
+    end
+
+    def stub_validation_messages
+      stub_default_validation_message
+      stub_attribute_specific_validation_message
+    end
+
+    def stub_default_validation_message
+      keys = [
+        'activerecord.errors.messages',
+        validation_message_key
+      ]
+
+      I18nFaker.stub_translation(keys, default_message)
+    end
+
+    def stub_attribute_specific_validation_message
+      keys = [
+        'activerecord.errors',
+        "models.#{builder.model_name.to_s.underscore}",
+        "attributes.#{builder.attribute_that_receives_error}",
+        validation_message_key
+      ]
+
+      I18nFaker.stub_translation(
+        keys,
+        message_for_attribute_that_receives_error
+      )
+    end
+
+    def default_message
+      'the wrong message'
+    end
+
+    def message_for_attribute_that_receives_error
+      'the right message'
+    end
+
+    def default_options
+      {
+        validation_message_key: :validation_message_key
+      }
+    end
+  end
+end

data/spec/support/unit/record_validating_confirmation_builder.rb

@@ -0,0 +1,56 @@
+require_relative 'helpers/model_builder'
+
+module UnitTests
+  class RecordValidatingConfirmationBuilder
+    include ModelBuilder
+
+    def initialize(options)
+      @options = options
+    end
+
+    def model
+      @_model ||= create_model
+    end
+
+    def model_name
+      'Example'
+    end
+
+    def record
+      model.new
+    end
+
+    def message=(message)
+      options[:message] = message
+    end
+
+    def attribute_to_confirm
+      :attribute_to_confirm
+    end
+    alias_method :attribute, :attribute_to_confirm
+
+    def confirmation_attribute
+      :"#{attribute_to_confirm}_confirmation"
+    end
+
+    def attribute_that_receives_error
+      Shoulda::Matchers::RailsShim.
+        validates_confirmation_of_error_attribute(self)
+    end
+
+    protected
+
+    attr_reader :options
+
+    private
+
+    def create_model
+      _attribute = attribute_to_confirm
+      _options = options
+
+      define_model(model_name, _attribute => :string) do
+        validates_confirmation_of(_attribute, _options)
+      end
+    end
+  end
+end

data/spec/support/unit/record_with_different_error_attribute_builder.rb

@@ -0,0 +1,92 @@
+require_relative 'helpers/model_builder'
+
+module UnitTests
+  class RecordWithDifferentErrorAttributeBuilder
+    include ModelBuilder
+
+    def initialize(options)
+      @options = options.reverse_merge(default_options)
+    end
+
+    def attribute_that_receives_error
+      options[:attribute_that_receives_error]
+    end
+
+    def attribute_to_validate
+      options[:attribute_to_validate]
+    end
+
+    def message
+      options[:message]
+    end
+
+    def message=(message)
+      options[:message] = message
+    end
+
+    def model
+      @_model ||= create_model
+    end
+
+    def model_name
+      'Example'
+    end
+
+    def record
+      model.new
+    end
+
+    def valid_value
+      'some value'
+    end
+
+    protected
+
+    attr_reader :options
+
+    private
+
+    def context
+      {
+        validation_method_name: validation_method_name,
+        valid_value: valid_value,
+        attribute_to_validate: attribute_to_validate,
+        attribute_that_receives_error: attribute_that_receives_error,
+        message: message
+      }
+    end
+
+    def create_model
+      _context = context
+
+      define_model model_name, model_columns do
+        validate _context[:validation_method_name]
+
+        define_method(_context[:validation_method_name]) do
+          if self[_context[:attribute_to_validate]] != _context[:valid_value]
+            self.errors.add(_context[:attribute_that_receives_error], _context[:message])
+          end
+        end
+      end
+    end
+
+    def validation_method_name
+      :custom_validation
+    end
+
+    def model_columns
+      {
+        attribute_to_validate => :string,
+        attribute_that_receives_error => :string
+      }
+    end
+
+    def default_options
+      {
+        attribute_that_receives_error: :attribute_that_receives_error,
+        attribute_to_validate: :attribute_to_validate,
+        message: 'some message'
+      }
+    end
+  end
+end

data/spec/support/{shared_examples → unit/shared_examples}/numerical_submatcher.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 shared_examples 'a numerical submatcher' do
   it 'implements the with_message method' do
     expect(subject).to respond_to(:with_message).with(1).arguments