shoulda-matchers 3.0.1 → 3.1.0

data/spec/support/unit/attribute.rb

@@ -0,0 +1,47 @@
+module UnitTests
+  class Attribute
+    attr_reader :name, :column_type, :column_options
+
+    DEFAULT_COLUMN_TYPE = :string
+    DEFAULT_COLUMN_OPTIONS = {
+      null: false,
+      array: false
+    }
+
+    def initialize(args)
+      @args = args
+    end
+
+    def name
+      args.fetch(:name)
+    end
+
+    def column_type
+      args.fetch(:column_type, DEFAULT_COLUMN_TYPE)
+    end
+
+    def column_options
+      DEFAULT_COLUMN_OPTIONS.
+        merge(args.fetch(:column_options, {})).
+        merge(type: column_type)
+    end
+
+    def array?
+      column_options[:array]
+    end
+
+    def default_value
+      args.fetch(:default_value) do
+        if column_options[:null]
+          nil
+        else
+          Shoulda::Matchers::Util.dummy_value_for(value_type, array: array?)
+        end
+      end
+    end
+
+    protected
+
+    attr_reader :args
+  end
+end

data/spec/support/unit/capture.rb

@@ -2,6 +2,8 @@ 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)
@@ -18,6 +20,8 @@ module Kernel
     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')
@@ -28,6 +32,8 @@ module Kernel
     old_stream.close
   end
 
+  undef_method :silence_stderr
+
   def silence_stderr
     silence_stream(STDERR) { yield }
   end

data/spec/support/unit/change_value.rb

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

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

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

@@ -0,0 +1,74 @@
+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_record_versions.rb

@@ -6,7 +6,7 @@ module UnitTests
     end
 
     def active_record_version
-      Tests::Version.new(ActiveRecord::VERSION::STRING)
+      Tests::Version.new(::ActiveRecord::VERSION::STRING)
     end
 
     def active_record_supports_enum?

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

@@ -1,76 +1,90 @@
 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]
+    def define_module(*args, &block)
+      ClassBuilder.define_module(*args, &block)
     end
 
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-
-      example_group.after do
-        teardown_defined_constants
-      end
+    def define_class(*args, &block)
+      ClassBuilder.define_class(*args, &block)
     end
 
-    def define_module(module_name, &block)
-      module_name = module_name.to_s.camelize
+    class << self
+      def configure_example_group(example_group)
+        example_group.include(self)
 
-      namespace, name_without_namespace =
-        ClassBuilder.parse_constant_name(module_name)
+        example_group.after do
+          ClassBuilder.reset
+        end
+      end
 
-      if namespace.const_defined?(name_without_namespace, false)
-        namespace.__send__(:remove_const, name_without_namespace)
+      def reset
+        remove_defined_classes
       end
 
-      eval <<-RUBY
-        module #{namespace}::#{name_without_namespace}
-        end
-      RUBY
+      def define_module(module_name, &block)
+        module_name = module_name.to_s.camelize
 
-      namespace.const_get(name_without_namespace).tap do |constant|
-        constant.unloadable
+        namespace, name_without_namespace =
+          ClassBuilder.parse_constant_name(module_name)
 
-        if block
-          constant.module_eval(&block)
+        if namespace.const_defined?(name_without_namespace, false)
+          namespace.__send__(:remove_const, name_without_namespace)
         end
-      end
-    end
 
-    def define_class(class_name, parent_class = Object, &block)
-      class_name = class_name.to_s.camelize
+        eval <<-RUBY
+          module #{namespace}::#{name_without_namespace}
+          end
+        RUBY
 
-      namespace, name_without_namespace =
-        ClassBuilder.parse_constant_name(class_name)
+        namespace.const_get(name_without_namespace).tap do |constant|
+          constant.unloadable
 
-      if namespace.const_defined?(name_without_namespace, false)
-        namespace.__send__(:remove_const, name_without_namespace)
+          if block
+            constant.module_eval(&block)
+          end
+        end
       end
 
-      eval <<-RUBY
-        class #{namespace}::#{name_without_namespace} < #{parent_class}
+      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
-      RUBY
 
-      namespace.const_get(name_without_namespace).tap do |constant|
-        constant.unloadable
+        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)
+          if block
+            if block.arity == 0
+              constant.class_eval(&block)
+            else
+              block.call(constant)
+            end
           end
         end
       end
-    end
 
-    private
+      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 teardown_defined_constants
-      ActiveSupport::Dependencies.clear
+      def remove_defined_classes
+        ::ActiveSupport::Dependencies.clear
+      end
     end
   end
 end