shoulda-matchers 3.1.0 → 5.2.0

data/spec/support/unit/capture.rb

@@ -1,40 +0,0 @@
-module Kernel
-  # #capture, #silence_stream, and #silence_stderr are deprecated after Rails
-  # 4.2 and will be removed in 5.0, so just override them completely here
-
-  undef_method :capture
-
-  def capture(stream)
-    stream = stream.to_s
-    captured_stream = Tempfile.new(stream)
-    stream_io = eval("$#{stream}")
-    origin_stream = stream_io.dup
-    stream_io.reopen(captured_stream)
-
-    yield
-
-    stream_io.rewind
-    return captured_stream.read
-  ensure
-    captured_stream.unlink
-    stream_io.reopen(origin_stream)
-  end
-
-  undef_method :silence_stream
-
-  def silence_stream(stream)
-    old_stream = stream.dup
-    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
-    stream.sync = true
-    yield
-  ensure
-    stream.reopen(old_stream)
-    old_stream.close
-  end
-
-  undef_method :silence_stderr
-
-  def silence_stderr
-    silence_stream(STDERR) { yield }
-  end
-end

data/spec/support/unit/change_value.rb

@@ -1,111 +0,0 @@
-module UnitTests
-  class ChangeValue
-    def self.call(column_type, value, value_changer)
-      new(column_type, value, value_changer).call
-    end
-
-    def initialize(column_type, value, value_changer)
-      @column_type = column_type
-      @value = value
-      @value_changer = value_changer
-    end
-
-    def call
-      if value_changer.is_a?(Proc)
-        value_changer.call(value)
-      elsif respond_to?(value_changer, true)
-        send(value_changer)
-      else
-        value.public_send(value_changer)
-      end
-    end
-
-    protected
-
-    attr_reader :column_type, :value, :value_changer
-
-    private
-
-    def previous_value
-      if value.is_a?(String)
-        value[0..-2] + (value[-1].ord - 1).chr
-      else
-        value - 1
-      end
-    end
-
-    def next_value
-      if value.is_a?(Array)
-        value + [value.first.class.new]
-      elsif value.respond_to?(:next)
-        value.next
-      else
-        value + 1
-      end
-    end
-
-    def next_next_value
-      change_value(change_value(value, :next_value), :next_value)
-    end
-
-    def next_value_or_numeric_value
-      if value
-        change_value(value, :next_value)
-      else
-        change_value(value, :numeric_value)
-      end
-    end
-
-    def next_value_or_non_numeric_value
-      if value
-        change_value(value, :next_value)
-      else
-        change_value(value, :non_numeric_value)
-      end
-    end
-
-    def never_falsy
-      value || dummy_value_for_column
-    end
-
-    def truthy_or_numeric
-      value || 1
-    end
-
-    def never_blank
-      value.presence || dummy_value_for_column
-    end
-
-    def nil_to_blank
-      value || ''
-    end
-
-    def always_nil
-      nil
-    end
-
-    def add_character
-      value + 'a'
-    end
-
-    def remove_character
-      value.chop
-    end
-
-    def numeric_value
-      '1'
-    end
-
-    def non_numeric_value
-      'a'
-    end
-
-    def change_value(value, value_changer)
-      self.class.call(column_type, value, value_changer)
-    end
-
-    def dummy_value_for_column
-      Shoulda::Matchers::Util.dummy_value_for(column_type)
-    end
-  end
-end

data/spec/support/unit/create_model_arguments/basic.rb

@@ -1,135 +0,0 @@
-require 'forwardable'
-
-module UnitTests
-  module CreateModelArguments
-    class Basic
-      DEFAULT_MODEL_NAME = 'Example'
-      DEFAULT_ATTRIBUTE_NAME = :attr
-      DEFAULT_COLUMN_TYPE = :string
-
-      def self.wrap(args)
-        if args.is_a?(self)
-          args
-        else
-          new(args)
-        end
-      end
-
-      extend Forwardable
-
-      def_delegators(
-        :attribute,
-        :column_type,
-        :column_options,
-        :default_value,
-        :value_type
-      )
-
-      def initialize(args)
-        @args = args
-      end
-
-      def fetch(*args, &block)
-        self.args.fetch(*args, &block)
-      end
-
-      def merge(given_args)
-        self.class.new(args.deep_merge(given_args))
-      end
-
-      def model_name
-        args.fetch(:model_name, DEFAULT_MODEL_NAME)
-      end
-
-      def attribute_name
-        args.fetch(:attribute_name, default_attribute_name)
-      end
-
-      def model_creation_strategy
-        args.fetch(:model_creation_strategy)
-      end
-
-      def columns
-        { attribute_name => column_options }
-      end
-
-      def attribute
-        @_attribute ||= attribute_class.new(attribute_args)
-      end
-
-      def all_attribute_overrides
-        @_all_attribute_overrides ||= begin
-          attribute_overrides = args.slice(
-            :changing_values_with,
-            :default_value
-          )
-
-          overrides =
-            if attribute_overrides.empty?
-              {}
-            else
-              { attribute_name => attribute_overrides }
-            end
-
-          overrides.deep_merge(args.fetch(:attribute_overrides, {}))
-        end
-      end
-
-      def attribute_overrides
-        all_attribute_overrides.fetch(attribute_name, {})
-      end
-
-      def validation_name
-        args.fetch(:validation_name) { map_matcher_name_to_validation_name }
-      end
-
-      def validation_options
-        args.fetch(:validation_options, {})
-      end
-
-      def custom_validation?
-        args.fetch(:custom_validation, false)
-      end
-
-      def matcher_name
-        args.fetch(:matcher_name)
-      end
-
-      def attribute_default_values_by_name
-        if attribute_overrides.key?(:default_value)
-          { attribute_name => attribute_overrides[:default_value] }
-        else
-          {}
-        end
-      end
-
-      def to_hash
-        args.deep_dup
-      end
-
-      protected
-
-      attr_reader :args
-
-      def attribute_class
-        UnitTests::Attribute
-      end
-
-      def default_attribute_name
-        DEFAULT_ATTRIBUTE_NAME
-      end
-
-      private
-
-      def map_matcher_name_to_validation_name
-        matcher_name.to_s.sub('validate', 'validates')
-      end
-
-      def attribute_args
-        args.slice(:column_type).deep_merge(
-          attribute_overrides.deep_merge(name: attribute_name)
-        )
-      end
-    end
-  end
-end

data/spec/support/unit/create_model_arguments/has_many.rb

@@ -1,15 +0,0 @@
-module UnitTests
-  module CreateModelArguments
-    class HasMany < Basic
-      def columns
-        super.except(attribute_name)
-      end
-
-      private
-
-      def default_attribute_name
-        :children
-      end
-    end
-  end
-end

data/spec/support/unit/create_model_arguments/uniqueness_matcher.rb

@@ -1,74 +0,0 @@
-module UnitTests
-  module CreateModelArguments
-    class UniquenessMatcher < Basic
-      def self.normalize_attribute(attribute)
-        if attribute.is_a?(Hash)
-          Attribute.new(attribute)
-        else
-          Attribute.new(name: attribute)
-        end
-      end
-
-      def self.normalize_attributes(attributes)
-        attributes.map do |attribute|
-          normalize_attribute(attribute)
-        end
-      end
-
-      def columns
-        attributes.reduce({}) do |options, attribute|
-          options.merge(
-            attribute.name => {
-              type: attribute.column_type,
-              options: attribute.column_options
-            }
-          )
-        end
-      end
-
-      def validation_options
-        super.merge(scope: scope_attribute_names)
-      end
-
-      def attribute_default_values_by_name
-        attributes.reduce({}) do |values, attribute|
-          values.merge(attribute.name => attribute.default_value)
-        end
-      end
-
-      protected
-
-      def attribute_class
-        Attribute
-      end
-
-      private
-
-      def attributes
-        [attribute] + scope_attributes + additional_attributes
-      end
-
-      def scope_attribute_names
-        scope_attributes.map(&:name)
-      end
-
-      def scope_attributes
-        @_scope_attributes ||= self.class.normalize_attributes(
-          args.fetch(:scopes, [])
-        )
-      end
-
-      def additional_attributes
-        @_additional_attributes ||= self.class.normalize_attributes(
-          args.fetch(:additional_attributes, [])
-        )
-      end
-
-      class Attribute < UnitTests::Attribute
-        def value_type
-          args.fetch(:value_type) { column_type }
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module UnitTests
-  module ActiveModelHelpers
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-    end
-
-    def custom_validation(options = {}, &block)
-      attribute_name = options.fetch(:attribute_name, :attr)
-      attribute_type = options.fetch(:attribute_type, :integer)
-      column_options = options.fetch(:column_options, {})
-      attribute_options = { type: attribute_type, options: column_options }
-
-      define_model(:example, attribute_name => attribute_options) do
-        validate :custom_validation
-
-        define_method(:custom_validation, &block)
-      end.new
-    end
-    alias record_with_custom_validation custom_validation
-
-    def validating_format(options)
-      define_model :example, attr: :string do
-        validates_format_of :attr, options
-      end.new
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module UnitTests
-  module ActiveModelVersions
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def active_model_version
-      Tests::Version.new(::ActiveModel::VERSION::STRING)
-    end
-
-    def active_model_3_1?
-      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1) || active_model_4_0?
-    end
-
-    def active_model_3_2?
-      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2) || active_model_4_0?
-    end
-
-    def active_model_4_0?
-      ::ActiveModel::VERSION::MAJOR == 4
-    end
-
-    def active_model_supports_strict?
-      active_model_version >= 3.2
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module UnitTests
-  module ActiveRecordVersions
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def active_record_version
-      Tests::Version.new(::ActiveRecord::VERSION::STRING)
-    end
-
-    def active_record_supports_enum?
-      defined?(::ActiveRecord::Enum)
-    end
-
-    def active_record_supports_has_secure_password?
-      active_record_version >= 3.1
-    end
-
-    def active_record_supports_array_columns?
-      active_record_version > 4.2
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'active_resource'
-
-module UnitTests
-  module ActiveResourceBuilder
-    def self.configure_example_group(example_group)
-      example_group.include ActiveResourceBuilder
-
-      example_group.after do
-        ActiveSupport::Dependencies.clear
-      end
-    end
-
-    def define_active_resource_class(class_name, attributes = {}, &block)
-      define_class(class_name, ActiveResource::Base) do
-        schema do
-          attributes.each do |attr, type|
-            attribute attr, type
-          end
-        end
-
-        if block_given?
-          class_eval(&block)
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-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

@@ -1,90 +0,0 @@
-module UnitTests
-  module ClassBuilder
-    def define_module(*args, &block)
-      ClassBuilder.define_module(*args, &block)
-    end
-
-    def define_class(*args, &block)
-      ClassBuilder.define_class(*args, &block)
-    end
-
-    class << self
-      def configure_example_group(example_group)
-        example_group.include(self)
-
-        example_group.after do
-          ClassBuilder.reset
-        end
-      end
-
-      def reset
-        remove_defined_classes
-      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
-            if block.arity == 0
-              constant.class_eval(&block)
-            else
-              block.call(constant)
-            end
-          end
-        end
-      end
-
-      def 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
-
-      private
-
-      def remove_defined_classes
-        ::ActiveSupport::Dependencies.clear
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module UnitTests
-  module ColumnTypeHelpers
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-    end
-
-    def column_type_class_namespace
-      if database_adapter == :postgresql
-        ActiveRecord::ConnectionAdapters::PostgreSQL
-      else
-        ActiveRecord::Type
-      end
-    end
-
-    def column_type_class_for(type)
-      namespace =
-        if type == :integer && database_adapter == :postgresql
-          column_type_class_namespace::OID
-        else
-          column_type_class_namespace
-        end
-
-      namespace.const_get(type.to_s.camelize)
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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 delete_temporary_views
-      $test_app.delete_temp_views
-    end
-
-    def restore_original_routes
-      Rails.application.reload_routes!
-    end
-  end
-end