shoulda-matchers 3.0.1 → 3.1.0

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

@@ -9,10 +9,12 @@ module UnitTests
       Tests::Database.instance.adapter_name
     end
 
-    def database_supports_uuid_columns?
+    def postgresql?
       database_adapter == :postgresql
     end
-    alias_method :database_supports_array_columns?,
-      :database_supports_uuid_columns?
+
+    alias_method :database_supports_array_columns?, :postgresql?
+    alias_method :database_supports_uuid_columns?, :postgresql?
+    alias_method :database_supports_money_columns?, :postgresql?
   end
 end

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

@@ -2,133 +2,113 @@ 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
+    def create_table(*args, &block)
+      ModelBuilder.create_table(*args, &block)
     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
+    def define_model(*args, &block)
+      ModelBuilder.define_model(*args, &block)
     end
 
-    def define_model_class(class_name, &block)
-      define_class(class_name, ActiveRecord::Base, &block)
+    def define_model_class(*args, &block)
+      ModelBuilder.define_model_class(*args, &block)
     end
 
-    def define_active_model_class(class_name, options = {}, &block)
-      accessors = options.fetch(:accessors, [])
-
-      define_class(class_name) do
-        include ActiveModel::Validations
+    def define_active_model_class(*args, &block)
+      ModelBuilder.define_active_model_class(*args, &block)
+    end
 
-        def initialize(attributes = {})
-          attributes.each do |name, value|
-            __send__("#{name}=", value)
-          end
-        end
+    class << self
+      def configure_example_group(example_group)
+        example_group.include(self)
 
-        accessors.each do |column|
-          attr_accessor column.to_sym
+        example_group.after do
+          ModelBuilder.reset
         end
+      end
 
-        if block_given?
-          class_eval(&block)
-        end
+      def reset
+        clear_column_caches
+        drop_created_tables
+        created_tables.clear
+        defined_models.clear
       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)
-            column_type = specification[:type]
-            column_options = specification.fetch(:options, {})
-          else
-            column_type = specification
-            column_options = {}
-          end
-
-          begin
-            table.__send__(column_type, column_name, column_options)
-          rescue NoMethodError
-            raise NoMethodError, "#{Tests::Database.instance.adapter_class} does not support :#{column_type} columns"
-          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
 
-      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)
+      def define_model_class(class_name, &block)
+        ClassBuilder.define_class(class_name, ::ActiveRecord::Base, &block)
       end
 
-      model = define_model_class(class_name).tap do |m|
-        if block
-          if block.arity == 0
-            m.class_eval(&block)
-          else
-            block.call(m)
-          end
+      def define_active_model_class(class_name, options = {}, &block)
+        attribute_names = options.delete(:accessors) { [] }
+
+        columns = attribute_names.reduce({}) do |hash, attribute_name|
+          hash.merge(attribute_name => nil)
         end
 
-        m.table_name = table_name
+        UnitTests::ModelCreationStrategies::ActiveModel.call(
+          'Example',
+          columns,
+          options,
+          &block
+        )
       end
 
-      defined_models << model
+      def define_model(name, columns = {}, options = {}, &block)
+        model = UnitTests::ModelCreationStrategies::ActiveRecord.call(
+          name,
+          columns,
+          options,
+          &block
+        )
+        defined_models << model
+        model
+      end
 
-      model
-    end
+      private
 
-    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
 
-    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!
+        defined_models.each do |model|
+          model.reset_column_information
+        end
       end
 
-      defined_models.each do |model|
-        model.reset_column_information
-      end
-    end
+      def drop_created_tables
+        connection = ::ActiveRecord::Base.connection
 
-    def drop_created_tables
-      connection = ActiveRecord::Base.connection
-
-      created_tables.each do |table_name|
-        connection.execute("DROP TABLE IF EXISTS #{table_name}")
+        created_tables.each do |table_name|
+          connection.execute("DROP TABLE IF EXISTS #{table_name}")
+        end
       end
-    end
 
-    def created_tables
-      @_created_tables ||= []
-    end
+      def created_tables
+        @_created_tables ||= []
+      end
 
-    def defined_models
-      @_defined_models ||= []
+      def defined_models
+        @_defined_models ||= []
+      end
     end
   end
 end

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

@@ -0,0 +1,44 @@
+module UnitTests
+  module ValidationMatcherScenarioHelpers
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+    end
+
+    def build_scenario_for_validation_matcher(args)
+      UnitTests::ValidationMatcherScenario.new(
+        build_validation_matcher_scenario_args(args)
+      )
+    end
+
+    protected
+
+    def validation_matcher_scenario_args
+      {}
+    end
+
+    def configure_validation_matcher(matcher)
+      matcher
+    end
+
+    private
+
+    def build_validation_matcher_scenario_args(args)
+      args.
+        deep_merge(validation_matcher_scenario_args).
+        deep_merge(
+          matcher_name: matcher_name,
+          matcher_proc: method(matcher_name)
+        )
+    end
+
+    def matcher_name
+      validation_matcher_scenario_args.fetch(:matcher_name) do
+        raise KeyNotFoundError.new(<<-MESSAGE)
+Please implement #validation_matcher_scenario_args in your example
+group, in such a way that it returns a hash that contains a
+:matcher_name key.
+        MESSAGE
+      end
+    end
+  end
+end

data/spec/support/unit/load_environment.rb

@@ -0,0 +1,12 @@
+require_relative '../tests/current_bundle'
+require_relative 'rails_application'
+
+Tests::CurrentBundle.instance.assert_appraisal!
+
+$test_app = UnitTests::RailsApplication.new
+$test_app.create
+$test_app.load
+
+require 'active_record/base'
+
+ENV['RAILS_ENV'] = 'test'

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

@@ -24,10 +24,10 @@ module UnitTests
         lines << Shoulda::Matchers::Util.indent(expected, 2)
 
         if @actual
-          lines << 'Actually failed with:'
+          lines << 'The full message was:'
           lines << Shoulda::Matchers::Util.indent(@actual, 2)
         else
-          lines << 'However, the expectation did not fail.'
+          lines << 'However, the expectation did not fail at all.'
         end
 
         lines.join("\n")

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

@@ -26,8 +26,13 @@ module UnitTests
         if @actual
           lines << 'Actually failed with:'
           lines << Shoulda::Matchers::Util.indent(@actual, 2)
+          lines << "Diff:"
+          lines << Shoulda::Matchers::Util.indent(
+            differ.diff(@actual, expected)[1..-1],
+            2
+          )
         else
-          lines << 'However, the expectation did not fail.'
+          lines << 'However, the expectation did not fail at all.'
         end
 
         lines.join("\n")
@@ -46,6 +51,12 @@ module UnitTests
       def failure_message_for_should_not
         failure_message_when_negated
       end
+
+      private
+
+      def differ
+        @_differ ||= RSpec::Support::Differ.new
+      end
     end
   end
 end

data/spec/support/unit/model_creation_strategies/active_model.rb

@@ -0,0 +1,111 @@
+module UnitTests
+  module ModelCreationStrategies
+    class ActiveModel
+      def self.call(name, columns = {}, options = {}, &block)
+        new(name, columns, options, &block).call
+      end
+
+      def initialize(name, columns = {}, options = {}, &block)
+        @name = name
+        @columns = columns
+        @options = options
+        @model_customizers = []
+
+        if block
+          customize_model(&block)
+        end
+      end
+
+      def customize_model(&block)
+        model_customizers << block
+      end
+
+      def call
+        ClassBuilder.define_class(name, Model).tap do |model|
+          model.columns = columns.keys
+
+          model_customizers.each do |block|
+            run_block(model, block)
+          end
+        end
+      end
+
+      protected
+
+      attr_reader :name, :columns, :model_customizers, :options
+
+      private
+
+      def run_block(model, block)
+        if block
+          if block.arity == 0
+            model.class_eval(&block)
+          else
+            block.call(model)
+          end
+        end
+      end
+
+      class Model
+        class << self
+          def columns
+            @_columns ||= []
+          end
+
+          def columns=(columns)
+            existing_columns = self.columns
+            new_columns = columns - existing_columns
+
+            @_columns += new_columns
+
+            include attributes_module
+
+            attributes_module.module_eval do
+              new_columns.each do |column|
+                define_method(column) do
+                  attributes[column]
+                end
+
+                define_method("#{column}=") do |value|
+                  attributes[column] = value
+                end
+              end
+            end
+          end
+
+          private
+
+          def attributes_module
+            @_attributes_module ||= Module.new
+          end
+        end
+
+        include ::ActiveModel::Model
+
+        attr_reader :attributes
+
+        def initialize(attributes = {})
+          @attributes = attributes.symbolize_keys
+        end
+
+        def inspect
+          middle = '%s:0x%014x%s' % [
+            self.class,
+            object_id * 2,
+            ' ' + inspected_attributes.join(' ')
+          ]
+
+          "#<#{middle.strip}>"
+        end
+
+        private
+
+        def inspected_attributes
+          self.class.columns.map do |key, value|
+            "#{key}: #{attributes[key].inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/unit/model_creation_strategies/active_record.rb

@@ -0,0 +1,77 @@
+module UnitTests
+  module ModelCreationStrategies
+    class ActiveRecord
+      def self.call(name, columns = {}, options = {}, &block)
+        new(name, columns, options, &block).call
+      end
+
+      def initialize(name, columns = {}, options = {}, &block)
+        @name = name
+        @columns = columns
+        @options = options
+        @model_customizers = []
+
+        if block
+          customize_model(&block)
+        end
+      end
+
+      def customize_model(&block)
+        model_customizers << block
+      end
+
+      def call
+        create_table_for_model
+        define_class_for_model
+      end
+
+      protected
+
+      attr_reader :columns, :model_customizers, :name, :options
+
+      private
+
+      def create_table_for_model
+        UnitTests::ActiveRecord::CreateTable.call(table_name, columns)
+      end
+
+      def define_class_for_model
+        model = UnitTests::ModelBuilder.define_model_class(class_name)
+
+        model_customizers.each do |block|
+          run_block(model, block)
+        end
+
+        if whitelist_attributes?
+          model.attr_accessible(*columns.keys)
+        end
+
+        model.table_name = table_name
+
+        model
+      end
+
+      def run_block(model, block)
+        if block
+          if block.arity == 0
+            model.class_eval(&block)
+          else
+            block.call(model)
+          end
+        end
+      end
+
+      def class_name
+        name.to_s.pluralize.classify
+      end
+
+      def table_name
+        class_name.tableize.gsub('/', '_')
+      end
+
+      def whitelist_attributes?
+        options.fetch(:whitelist_attributes, true)
+      end
+    end
+  end
+end