shoulda-matchers 2.7.0 → 2.8.0.rc1

data/spec/support/unit/helpers/allow_value_matcher_helpers.rb

@@ -0,0 +1,15 @@
+require_relative '../record_with_different_error_attribute_builder'
+require_relative '../record_builder_with_i18n_validation_message'
+
+module UnitTests
+  module AllowValueMatcherHelpers
+    def builder_for_record_with_different_error_attribute(options = {})
+      RecordWithDifferentErrorAttributeBuilder.new(options)
+    end
+
+    def builder_for_record_with_different_error_attribute_using_i18n(options = {})
+      builder = builder_for_record_with_different_error_attribute(options)
+      RecordBuilderWithI18nValidationMessage.new(builder)
+    end
+  end
+end

data/spec/support/unit/helpers/class_builder.rb

@@ -0,0 +1,72 @@
+module UnitTests
+  module ClassBuilder
+    def self.parse_constant_name(name)
+      namespace = Shoulda::Matchers::Util.deconstantize(name)
+      qualified_namespace = (namespace.presence || 'Object').constantize
+      name_without_namespace = name.to_s.demodulize
+      [qualified_namespace, name_without_namespace]
+    end
+
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+
+      example_group.after do
+        teardown_defined_constants
+      end
+    end
+
+    def define_module(module_name, &block)
+      module_name = module_name.to_s.camelize
+
+      namespace, name_without_namespace =
+        ClassBuilder.parse_constant_name(module_name)
+
+      if namespace.const_defined?(name_without_namespace, false)
+        namespace.__send__(:remove_const, name_without_namespace)
+      end
+
+      eval <<-RUBY
+        module #{namespace}::#{name_without_namespace}
+        end
+      RUBY
+
+      namespace.const_get(name_without_namespace).tap do |constant|
+        constant.unloadable
+
+        if block
+          constant.module_eval(&block)
+        end
+      end
+    end
+
+    def define_class(class_name, parent_class = Object, &block)
+      class_name = class_name.to_s.camelize
+
+      namespace, name_without_namespace =
+        ClassBuilder.parse_constant_name(class_name)
+
+      if namespace.const_defined?(name_without_namespace, false)
+        namespace.__send__(:remove_const, name_without_namespace)
+      end
+
+      eval <<-RUBY
+        class #{namespace}::#{name_without_namespace} < #{parent_class}
+        end
+      RUBY
+
+      namespace.const_get(name_without_namespace).tap do |constant|
+        constant.unloadable
+
+        if block_given?
+          constant.class_eval(&block)
+        end
+      end
+    end
+
+    private
+
+    def teardown_defined_constants
+      ActiveSupport::Dependencies.clear
+    end
+  end
+end

data/spec/support/unit/helpers/confirmation_matcher_helpers.rb

@@ -0,0 +1,17 @@
+require_relative '../record_validating_confirmation_builder'
+require_relative '../record_builder_with_i18n_validation_message'
+
+module UnitTests
+  module ConfirmationMatcherHelpers
+    def builder_for_record_validating_confirmation(options = {})
+      RecordValidatingConfirmationBuilder.new(options)
+    end
+
+    def builder_for_record_validating_confirmation_with_18n_message(options = {})
+      builder = builder_for_record_validating_confirmation(options)
+      RecordBuilderWithI18nValidationMessage.new(builder,
+        validation_message_key: :confirmation
+      )
+    end
+  end
+end

data/spec/support/unit/helpers/controller_builder.rb

@@ -0,0 +1,91 @@
+module UnitTests
+  module ControllerBuilder
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+
+      example_group.after do
+        delete_temporary_views
+        restore_original_routes
+      end
+    end
+
+    def define_controller(class_name, &block)
+      class_name = class_name.to_s
+      class_name << 'Controller' unless class_name =~ /Controller$/
+      define_class(class_name, ActionController::Base, &block)
+    end
+
+    def define_routes(&block)
+      self.routes = $test_app.draw_routes(&block)
+    end
+
+    def build_fake_response(opts = {}, &block)
+      action = opts[:action] || 'example'
+      partial = opts[:partial] || '_partial'
+      block ||= lambda { render nothing: true }
+      controller_class = define_controller('Examples') do
+        layout false
+        define_method(action, &block)
+      end
+      controller_class.view_paths = [ $test_app.temp_views_directory.to_s ]
+
+      define_routes do
+        get 'examples', to: "examples##{action}"
+      end
+
+      create_view("examples/#{action}.html.erb", 'action')
+      create_view("examples/#{partial}.html.erb", 'partial')
+
+      setup_rails_controller_test(controller_class)
+      self.class.render_views(true)
+
+      get action
+
+      controller
+    end
+
+    def setup_rails_controller_test(controller_class)
+      @controller = controller_class.new
+    end
+
+    def create_view(path, contents)
+      $test_app.create_temp_view(path, contents)
+    end
+
+    def controller_for_resource_with_strong_parameters(options = {}, &action_body)
+      model_name = options.fetch(:model_name, 'User')
+      controller_name = options.fetch(:controller_name, 'UsersController')
+      collection_name = controller_name.
+        to_s.sub(/Controller$/, '').underscore.
+        to_sym
+      action_name = options.fetch(:action, :some_action)
+      routes ||= options.fetch(:routes, -> { resources collection_name })
+
+      define_model(model_name)
+
+      controller_class = define_controller(controller_name) do
+        define_method action_name do
+          if action_body
+            instance_eval(&action_body)
+          end
+
+          render nothing: true
+        end
+      end
+
+      setup_rails_controller_test(controller_class)
+
+      define_routes(&routes)
+
+      controller_class
+    end
+
+    def delete_temporary_views
+      $test_app.delete_temp_views
+    end
+
+    def restore_original_routes
+      Rails.application.reload_routes!
+    end
+  end
+end

data/spec/support/unit/helpers/i18n_faker.rb

@@ -0,0 +1,15 @@
+module UnitTests
+  module I18nFaker
+    extend self
+
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+    end
+
+    def stub_translation(key_or_keys, message)
+      keys = [key_or_keys].flatten.join('.').split('.')
+      tree = keys.reverse.inject(message) { |data, key| { key => data } }
+      I18n.backend.store_translations(:en, tree)
+    end
+  end
+end

data/spec/support/unit/helpers/mailer_builder.rb

@@ -0,0 +1,12 @@
+module UnitTests
+  module MailerBuilder
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+    end
+
+    def define_mailer(name, paths, &block)
+      class_name = name.to_s.pluralize.classify
+      define_class(class_name, ActionMailer::Base, &block)
+    end
+  end
+end

data/spec/support/unit/helpers/model_builder.rb

@@ -0,0 +1,102 @@
+require_relative 'class_builder'
+
+module UnitTests
+  module ModelBuilder
+    include ClassBuilder
+
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+
+      example_group.after do
+        clear_column_caches
+        drop_created_tables
+      end
+    end
+
+    def create_table(table_name, options = {}, &block)
+      connection = ActiveRecord::Base.connection
+
+      begin
+        connection.execute("DROP TABLE IF EXISTS #{table_name}")
+        connection.create_table(table_name, options, &block)
+        created_tables << table_name
+        connection
+      rescue Exception => e
+        connection.execute("DROP TABLE IF EXISTS #{table_name}")
+        raise e
+      end
+    end
+
+    def define_model_class(class_name, &block)
+      define_class(class_name, ActiveRecord::Base, &block)
+    end
+
+    def define_active_model_class(class_name, options = {}, &block)
+      define_class(class_name) do
+        include ActiveModel::Validations
+
+        options[:accessors].each do |column|
+          attr_accessor column.to_sym
+        end
+
+        if block_given?
+          class_eval(&block)
+        end
+      end
+    end
+
+    def define_model(name, columns = {}, &block)
+      class_name = name.to_s.pluralize.classify
+      table_name = class_name.tableize.gsub('/', '_')
+
+      table_block = lambda do |table|
+        columns.each do |column_name, specification|
+          if specification.is_a?(Hash)
+            table.column column_name, specification[:type], specification[:options]
+          else
+            table.column column_name, specification
+          end
+        end
+      end
+
+      if columns.key?(:id) && columns[:id] == false
+        columns.delete(:id)
+        create_table(table_name, id: false, &table_block)
+      else
+        create_table(table_name, &table_block)
+      end
+
+      define_model_class(class_name).tap do |model|
+        if block
+          model.class_eval(&block)
+        end
+
+        model.table_name = table_name
+      end
+    end
+
+    private
+
+    def clear_column_caches
+      # Rails 4.x
+      if ActiveRecord::Base.connection.respond_to?(:schema_cache)
+        ActiveRecord::Base.connection.schema_cache.clear!
+      # Rails 3.1 - 4.0
+      elsif ActiveRecord::Base.connection_pool.respond_to?(:clear_cache!)
+        ActiveRecord::Base.connection_pool.clear_cache!
+      end
+    end
+
+    def drop_created_tables
+      connection = ActiveRecord::Base.connection
+
+      created_tables.each do |table_name|
+        connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      end
+    end
+
+    def created_tables
+      @_created_tables ||= []
+    end
+  end
+end

data/spec/support/unit/helpers/rails_versions.rb

@@ -0,0 +1,28 @@
+module UnitTests
+  module RailsVersions
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+      example_group.extend(self)
+    end
+
+    def rails_version
+      Gem::Version.new(Rails::VERSION::STRING)
+    end
+
+    def rails_3_x?
+      Gem::Requirement.new('~> 3.0').satisfied_by?(rails_version)
+    end
+
+    def rails_4_x?
+      Gem::Requirement.new('~> 4.0').satisfied_by?(rails_version)
+    end
+
+    def rails_gte_4_1?
+      Gem::Requirement.new('>= 4.1').satisfied_by?(rails_version)
+    end
+
+    def active_record_supports_enum?
+      defined?(::ActiveRecord::Enum)
+    end
+  end
+end

data/spec/support/unit/i18n.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.after do
+    # Clear any translations added during tests by telling the backend to
+    # replace its translations with whatever is in the YAML files.
+    I18n.backend.reload!
+  end
+end

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

@@ -0,0 +1,60 @@
+module UnitTests
+  module Matchers
+    def deprecate(old_method, new_method)
+      DeprecateMatcher.new(old_method, new_method)
+    end
+
+    class DeprecateMatcher
+      def initialize(old_method, new_method)
+        @old_method = old_method
+        @new_method = new_method
+      end
+
+      def matches?(block)
+        @captured_stderr = capture(:stderr, &block).gsub(/\n+/, ' ')
+        captured_stderr.include?(expected_message)
+      end
+
+      def failure_message
+        "Expected block to #{expectation}, but it did not.\nActual warning: #{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 :old_method, :new_method, :captured_stderr
+
+      private
+
+      def expected_message
+        "#{old_method} is deprecated and will be removed in the next major release. Please use #{new_method} instead."
+      end
+
+      def expectation
+        "print a warning deprecating #{old_method} in favor of #{new_method}"
+      end
+
+      def actual_warning
+        if captured_stderr.empty?
+          "nothing"
+        else
+          "\n  #{captured_stderr}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module UnitTests
+  module Matchers
+    extend RSpec::Matchers::DSL
+
+    matcher :fail_with_message_including 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.include?(expected)
+      end
+
+      def failure_message
+        msg = "Expectation should have failed with message including '#{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 including '#{expected}'"
+        msg << ", but did."
+
+        msg
+      end
+
+      def failure_message_for_should_not
+        failure_message_when_negated
+      end
+    end
+  end
+end