shoulda-matchers 3.1.0 → 5.2.0

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

@@ -1,20 +0,0 @@
-module UnitTests
-  module DatabaseHelpers
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def database_adapter
-      Tests::Database.instance.adapter_name
-    end
-
-    def postgresql?
-      database_adapter == :postgresql
-    end
-
-    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/i18n_faker.rb

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

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

@@ -1,114 +0,0 @@
-require_relative 'class_builder'
-
-module UnitTests
-  module ModelBuilder
-    def create_table(*args, &block)
-      ModelBuilder.create_table(*args, &block)
-    end
-
-    def define_model(*args, &block)
-      ModelBuilder.define_model(*args, &block)
-    end
-
-    def define_model_class(*args, &block)
-      ModelBuilder.define_model_class(*args, &block)
-    end
-
-    def define_active_model_class(*args, &block)
-      ModelBuilder.define_active_model_class(*args, &block)
-    end
-
-    class << self
-      def configure_example_group(example_group)
-        example_group.include(self)
-
-        example_group.after do
-          ModelBuilder.reset
-        end
-      end
-
-      def reset
-        clear_column_caches
-        drop_created_tables
-        created_tables.clear
-        defined_models.clear
-      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)
-        ClassBuilder.define_class(class_name, ::ActiveRecord::Base, &block)
-      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
-
-        UnitTests::ModelCreationStrategies::ActiveModel.call(
-          'Example',
-          columns,
-          options,
-          &block
-        )
-      end
-
-      def define_model(name, columns = {}, options = {}, &block)
-        model = UnitTests::ModelCreationStrategies::ActiveRecord.call(
-          name,
-          columns,
-          options,
-          &block
-        )
-        defined_models << model
-        model
-      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
-
-        defined_models.each do |model|
-          model.reset_column_information
-        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
-
-      def defined_models
-        @_defined_models ||= []
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module UnitTests
-  module RailsVersions
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def rails_version
-      Tests::Version.new(Rails::VERSION::STRING)
-    end
-
-    def rails_3_x?
-      rails_version =~ '~> 3.0'
-    end
-
-    def rails_4_x?
-      rails_version =~ '~> 4.0'
-    end
-
-    def rails_gte_4_1?
-      rails_version >= 4.1
-    end
-
-    def rails_gte_4_2?
-      rails_version >= 4.2
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-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/i18n.rb

@@ -1,7 +0,0 @@
-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/load_environment.rb

@@ -1,12 +0,0 @@
-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/deprecate.rb

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

@@ -1,51 +0,0 @@
-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
-        lines = ['Expectation should have failed with message including:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-
-        if @actual
-          lines << 'The full message was:'
-          lines << Shoulda::Matchers::Util.indent(@actual, 2)
-        else
-          lines << 'However, the expectation did not fail at all.'
-        end
-
-        lines.join("\n")
-      end
-
-      def failure_message_for_should
-        failure_message
-      end
-
-      def failure_message_when_negated
-        lines = ['Expectation should not have failed with message including:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-        lines.join("\n")
-      end
-
-      def failure_message_for_should_not
-        failure_message_when_negated
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-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.sub(/\n\z/, '')
-      end
-
-      def failure_message
-        lines = ['Expectation should have failed with message:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-
-        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 at all.'
-        end
-
-        lines.join("\n")
-      end
-
-      def failure_message_for_should
-        failure_message
-      end
-
-      def failure_message_when_negated
-        lines = ['Expectation should not have failed with message:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-        lines.join("\n")
-      end
-
-      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/matchers/print_warning_including.rb

@@ -1,59 +0,0 @@
-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/model_creation_strategies/active_model.rb

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

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