phillumeny 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8403edeb95537840758d0411c34a4cb4eac959f3ae89498309a1c3faf62c7b59
-  data.tar.gz: cdddf19e194bdf21d13f8beaaf58f5e8185986cd443b5867381033c4c872edcb
+  metadata.gz: cc29628456bbe7ab061f91f3a0519fee437a3351151c66b83b37a93bd5c40573
+  data.tar.gz: 3c1e8512e573d04b100ba7b37fa2e96fb310f29aa47041c442a7ab9d04720d8c
 SHA512:
-  metadata.gz: 31e35ad66e92c1618c210c2a3a26a5d5a6f14b136c31179314e0b990d132c40163943ba0a1f213fc9e5989d9d5eabf8f6a7a8d8d3b8f7834a168d418d73f803e
-  data.tar.gz: 37a789b49915fb23ce58f7cf4ee1863226eada76cbef064b173440bac967e9cca55864519aef919345144dd5b78ae6296a93e27de0b860c65c281795e750a78c
+  metadata.gz: f7a5bb55690d759ebdfb51b7d324621347cfbac9bdd08d58db15b3a5d318d9b87a7d2fba8477d6d6fd97c9a138762fe84361aea8a7b15472c0c2d758cf021de9
+  data.tar.gz: 65cb57ad917ce2a1132335d966d1b88b1a624c34fc610e051230af77d42e595e499b221d7b8606ae0063f377c5eb2156b12e3dd6983a4f0a8697c44964c89615

data/lib/phillumeny.rb

@@ -3,6 +3,7 @@
 require 'phillumeny/version'
 
 require 'phillumeny/active_model'
+require 'phillumeny/active_record'
 require 'phillumeny/factory_bot'
 
 # Phillumeny is a collection of RSpec matchers for verbose testers that I use to fills some of the gaps

data/lib/phillumeny/active_model.rb

@@ -1,203 +1,8 @@
 # frozen_string_literal: true
 
 module Phillumeny
-
-  # Matchers  testing ActiveModel functionality
-  module ActiveModel
-
-    def validate_presence_of_any(*args)
-      ValidatePresenceOfAny.new(args)
-    end
-
-    # Used for testing conditional validation of presence where you need one of the other
-    #
-    # @example
-    #
-    #   class Webpage
-    #
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :body
-    #     attr_accessor :headline
-    #     attr_accessor :title
-    #
-    #     validates :body,
-    #               presence: true
-    #
-    #     validates :headline,
-    #               presence: true,
-    #               unless: -> { title.present? }
-    #
-    #     validates :title,
-    #               presence: true,
-    #               inclusion: { allow_blank: true, in: ['this'] },
-    #               unless: -> { headline.present? && headline != 'needs title' }
-    #
-    #   end
-    #
-    #   RSpec.describe Webpage, type: :model do
-    #
-    #     it { should     validate_presence_of_any(:headline, :title).valid_values(title: 'this') }
-    #     it { should_not validate_presence_of_any(:headline, :title) }
-    #     it { should_not validate_presence_of_any(:headline, :title).valid_value(:title, 'that') }
-    #
-    #   end
-    class ValidatePresenceOfAny
-
-      attr_reader :attributes
-      attr_reader :subject
-
-      # Description used when matcher is used
-      #
-      # @api private
-      #
-      # @return [String]
-      def description
-        "validate the presence of any of these attributes: #{attributes.join(', ')}"
-      end
-
-      # Compiles the error message for display
-      #
-      # @api private
-      #
-      # @return [String]
-      def failure_message
-        messages = [subject.inspect]
-        attributes.each do |attribute|
-          messages << subject.errors.full_messages_for(attribute)
-        end
-        messages.compact.join("\n")
-      end
-
-      # Sets up arguments for the matcher
-      #
-      # @api private
-      #
-      # @return [void]
-      def initialize(args)
-        @attributes = args
-      end
-
-      # Runs the logic to determine if expectations are being met
-      #
-      # @api private
-      #
-      # @return [Boolean]
-      def matches?(subject)
-        @subject = subject
-        store_initial_values
-        invalid_when_none_present? && attributes.all? do |attribute|
-          clear_attributes_and_errors
-          initialize_value(attribute)
-          free_of_errors_on_attribute?(attribute) ? other_attributes_valid?(attribute) : false
-        end
-      end
-
-      # Explicitly set the value to test for an attribute if 'X' is not acceptable
-      #
-      # @api public
-      #
-      # @example
-      #   it { should validate_presence_of_any(:headline, :title).valid_value(:title, 'A valid title') }
-      #
-      # @return [self]
-      def valid_value(attribute, value)
-        attribute_values[attribute] = value
-        self
-      end
-
-      # Explicitly set the value to test for an attribute if 'X' is not acceptable
-      #
-      # @api public
-      #
-      # @example
-      #   it do
-      #     should validate_presence_of_any(:headline, :title).valid_values(title: 'A valid title')
-      #   end
-      #
-      # @return [self]
-      def valid_values(**values)
-        attribute_values.merge!(values)
-        self
-      end
-
-      private
-
-      # Storage for our initial and valid values for the attributes we are testing against
-      #
-      # @api private
-      #
-      # @return [Hash]
-      def attribute_values
-        @attribute_values ||= {}
-      end
-
-      # Clears all of the attributes that we are testing against
-      #
-      # @api private
-      #
-      # @return [void]
-      def clear_attributes_and_errors
-        attributes.each do |attribute|
-          subject.send("#{attribute}=", nil)
-        end
-        subject.errors.clear
-      end
-
-      # Checks that the current attribute we are checking against passes its other validations
-      #
-      # @api private
-      #
-      # @return [Boolean]
-      def free_of_errors_on_attribute?(attribute)
-        subject.class.validators_on(attribute).each do |validator|
-          # Can/do we use self[attribute] here or would that be better used in the
-          # conditional Proc on the validation itself?
-          validator.validate_each(subject, attribute, subject.send(attribute))
-        end
-        subject.errors[attribute].empty?
-      end
-
-      # Sets the value of the attribute that we currently testing against
-      #
-      # @api private
-      #
-      # @return [void]
-      def initialize_value(attribute)
-        subject.send("#{attribute}=", attribute_values[attribute] || 'X')
-      end
-
-      def invalid_when_none_present?
-        clear_attributes_and_errors
-        !subject.valid? && attributes.all? { |attribute| subject.errors[attribute].present? }
-      end
-
-      # Checks that the other attributes that we are checking against are valid as promised
-      #
-      # @api private
-      #
-      # @return [Boolean]
-      def other_attributes_valid?(exclude_attribute)
-        subject.valid?
-        (attributes - [exclude_attribute]).all? do |attribute|
-          subject.errors[attribute].empty?
-        end
-      end
-
-      # Store the initial values of our subject before we start messing around with it
-      #
-      # @api private
-      #
-      # @return [void]
-      def store_initial_values
-        attributes.each do |attribute|
-          next if attribute_values.key?(attribute)
-          attribute_values[attribute] = subject.send(attribute)
-        end
-      end
-
-    end
-
+  module ActiveModel # :nodoc:
   end
-
 end
+
+require 'phillumeny/active_model/validate_presence_of_any'

data/lib/phillumeny/active_model/validate_presence_of_any.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Phillumeny
+
+  module ActiveModel # :nodoc:
+
+    def validate_presence_of_any(*args)
+      ValidatePresenceOfAny.new(args)
+    end
+
+    # Used for testing conditional validation of presence where you need one of the other
+    #
+    # @example
+    #
+    #   class Webpage
+    #
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :body
+    #     attr_accessor :headline
+    #     attr_accessor :title
+    #
+    #     validates :body,
+    #               presence: true
+    #
+    #     validates :headline,
+    #               presence: true,
+    #               unless: -> { title.present? }
+    #
+    #     validates :title,
+    #               presence: true,
+    #               inclusion: { allow_blank: true, in: ['this'] },
+    #               unless: -> { headline.present? && headline != 'needs title' }
+    #
+    #   end
+    #
+    #   RSpec.describe Webpage, type: :model do
+    #
+    #     it { should     validate_presence_of_any(:headline, :title).valid_values(title: 'this') }
+    #     it { should_not validate_presence_of_any(:headline, :title) }
+    #     it { should_not validate_presence_of_any(:headline, :title).valid_value(:title, 'that') }
+    #
+    #   end
+    class ValidatePresenceOfAny
+
+      attr_reader :attributes
+      attr_reader :subject
+
+      # Description used when matcher is used
+      #
+      # @api private
+      #
+      # @return [String]
+      def description
+        "validate the presence of any of these attributes: #{attributes.join(', ')}"
+      end
+
+      # Compiles the error message for display
+      #
+      # @api private
+      #
+      # @return [String]
+      def failure_message
+        messages = [subject.inspect]
+        attributes.each do |attribute|
+          messages << subject.errors.full_messages_for(attribute)
+        end
+        messages.compact.join("\n")
+      end
+
+      # Sets up arguments for the matcher
+      #
+      # @api private
+      #
+      # @return [void]
+      def initialize(args)
+        @attributes = args
+      end
+
+      # Runs the logic to determine if expectations are being met
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      def matches?(subject)
+        @subject = subject
+        store_initial_values
+        invalid_when_none_present? && attributes.all? do |attribute|
+          clear_attributes_and_errors
+          initialize_value(attribute)
+          free_of_errors_on_attribute?(attribute) ? other_attributes_valid?(attribute) : false
+        end
+      end
+
+      # Explicitly set the value to test for an attribute if 'X' is not acceptable
+      #
+      # @api public
+      #
+      # @example
+      #   it { should validate_presence_of_any(:headline, :title).valid_value(:title, 'A valid title') }
+      #
+      # @return [self]
+      def valid_value(attribute, value)
+        attribute_values[attribute] = value
+        self
+      end
+
+      # Explicitly set the value to test for an attribute if 'X' is not acceptable
+      #
+      # @api public
+      #
+      # @example
+      #   it do
+      #     should validate_presence_of_any(:headline, :title).valid_values(title: 'A valid title')
+      #   end
+      #
+      # @return [self]
+      def valid_values(**values)
+        attribute_values.merge!(values)
+        self
+      end
+
+      private
+
+      # Storage for our initial and valid values for the attributes we are testing against
+      #
+      # @api private
+      #
+      # @return [Hash]
+      def attribute_values
+        @attribute_values ||= {}
+      end
+
+      # Clears all of the attributes that we are testing against
+      #
+      # @api private
+      #
+      # @return [void]
+      def clear_attributes_and_errors
+        attributes.each do |attribute|
+          subject.send("#{attribute}=", nil)
+        end
+        subject.errors.clear
+      end
+
+      # Checks that the current attribute we are checking against passes its other validations
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      def free_of_errors_on_attribute?(attribute)
+        subject.class.validators_on(attribute).each do |validator|
+          # Can/do we use self[attribute] here or would that be better used in the
+          # conditional Proc on the validation itself?
+          validator.validate_each(subject, attribute, subject.send(attribute))
+        end
+        subject.errors[attribute].empty?
+      end
+
+      # Sets the value of the attribute that we currently testing against
+      #
+      # @api private
+      #
+      # @return [void]
+      def initialize_value(attribute)
+        subject.send("#{attribute}=", attribute_values[attribute] || 'X')
+      end
+
+      def invalid_when_none_present?
+        clear_attributes_and_errors
+        !subject.valid? && attributes.all? { |attribute| subject.errors[attribute].present? }
+      end
+
+      # Checks that the other attributes that we are checking against are valid as promised
+      #
+      # @api private
+      #
+      # @return [Boolean]
+      def other_attributes_valid?(exclude_attribute)
+        subject.valid?
+        (attributes - [exclude_attribute]).all? do |attribute|
+          subject.errors[attribute].empty?
+        end
+      end
+
+      # Store the initial values of our subject before we start messing around with it
+      #
+      # @api private
+      #
+      # @return [void]
+      def store_initial_values
+        attributes.each do |attribute|
+          next if attribute_values.key?(attribute)
+          attribute_values[attribute] = subject.send(attribute)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/phillumeny/active_record.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Phillumeny
+  module ActiveRecord # :nodoc:
+
+    # Helper methods for working with the database
+    #
+    # All the methods depend on the @subject instance variable being set
+    module TableInformation
+
+      protected
+
+      def model_class
+        @model_class ||= @subject.class
+      end
+
+      # Retrieve all the table
+      def table_columns
+        @table_columns ||= ::ActiveRecord::Base.connection.columns(table_name)
+      end
+
+      def table_indexes
+        @table_indexes ||= ::ActiveRecord::Base.connection.indexes(table_name)
+      end
+
+      def table_name
+        @table_name ||= model_class.table_name
+      end
+
+    end
+  end
+end
+
+require 'phillumeny/active_record/cover_query_with_indexes'
+require 'phillumeny/active_record/have_default_value_of'

data/lib/phillumeny/active_record/cover_query_with_indexes.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Phillumeny
+
+  module ActiveRecord # :nodoc:
+
+    # Comb through indexes to ensure the columns are covered
+    #
+    # @api public
+    #
+    # @example
+    #
+    #   [:col1, [:col1, :col2], :col2].each do |columns|
+    #     it { should cover_query_with_indexes columns }
+    #   end
+    #
+    # @return [Phillumeny::ActiveRecord::CoverQueryWithIndexes]
+    def cover_query_with_indexes(columns)
+      CoverQueryWithIndexes.new(columns)
+    end
+
+    # There is often a misunderstanding on how database indexes
+    # work when you are indexing across multiple columns. An index
+    # created for the columns [:col1, :col2] will *usually* cover
+    # where clauses against :col1 and [:col2, :col1] also but does not
+    # guarantee it will be even used if a where clause only has :col2.
+    class CoverQueryWithIndexes
+
+      include Phillumeny::ActiveRecord::TableInformation
+
+      def initialize(columns)
+        self.columns = Array(columns).map(&:to_s)
+      end
+
+      def description
+        "have database indexes that would cover #{columns}"
+      end
+
+      def failure_message
+        return "No database column(s) found for #{invalid_columns.inspect}" unless valid_columns?
+        "The table #{table_name} did not have index to cover queries for #{columns}"
+      end
+
+      def matches?(subject)
+        @subject = subject
+        valid_columns? && matching_index?
+      end
+
+      private
+
+      attr_accessor :columns
+
+      def invalid_columns
+        @invalid_columns ||= columns.reject do |col_name|
+          ::ActiveRecord::Base.connection.column_exists?(table_name, col_name)
+        end
+      end
+
+      def matching_index?
+        sized_table_indexs_columns.any? do |relevent_columns|
+          (columns - relevent_columns).empty?
+        end
+      end
+
+      def sized_table_indexs_columns
+        table_indexes.map { |index| index.columns.first(columns.size) }
+      end
+
+      def valid_columns?
+        invalid_columns.empty?
+      end
+
+    end
+
+  end
+
+end

data/lib/phillumeny/active_record/have_default_value_of.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Phillumeny
+
+  module ActiveRecord # :nodoc:
+
+    # Confirm a default value is getting returned as expected
+    #
+    # @api public
+    #
+    # @example
+    #
+    #   { user_id: nil, timezone: 'PDT' }.each do |attribute, value|
+    #     # Just checks the subject that the right value is present
+    #     it { should have_default_value_of(value).for(attribute) }
+    #   end
+    #
+    #   # Checks both the subject and confirms at the database column level
+    #   it { should have_default_value_of('PDT').for(:timezone).in_the_database }
+    #
+    # @return [Phillumeny::ActiveRecord::HaveADefaultValueOf]
+    def have_default_value_of(default_value)
+      HaveDefaultValueOf.new(default_value)
+    end
+
+    class HaveDefaultValueOf # :nodoc:
+      # @note
+      #   Part of this could live outside of the ActiveRecord module but we have
+      #   an option here to confirm and check the database also so leaving
+      #   it in here for now
+
+      include Phillumeny::ActiveRecord::TableInformation
+
+      def description
+        "have a default value of '#{default_value}':#{default_value.class} for #{attribute_name}"
+      end
+
+      def failure_message
+        # rubocop:disable LineLength
+        "The value of '#{value_for_attribute}':#{value_for_attribute.class} was found not '#{default_value}':#{default_value.class}"
+        # rubocop:enable LineLength
+      end
+
+      def for(attribute_name)
+        self.attribute_name = attribute_name
+        self
+      end
+
+      def in_the_database
+        self.check_column_default = true
+        self
+      end
+
+      def initialize(default_value)
+        self.default_value = default_value
+      end
+
+      def matches?(subject)
+        @subject = subject
+        default_value_found? && column_configured_for_default_value?
+      end
+
+      protected
+
+      attr_accessor :attribute_name, :check_column_default, :default_value
+
+      private
+
+      def column
+        @column ||= table_columns.find { |column| column.name == attribute_name.to_s }
+      end
+
+      def column_configured_for_default_value?
+        return true unless @check_column_default
+        default_column_value == default_value
+      end
+
+      def column_type
+        @column_type ||= ::ActiveModel::Type.lookup(column.type)
+      end
+
+      def default_column_value
+        column_type.deserialize(column.default)
+      end
+
+      def default_value_found?
+        value_for_attribute == default_value
+      end
+
+      def value_for_attribute
+        @subject.send(attribute_name)
+      end
+
+    end
+
+  end
+
+end

data/lib/phillumeny/version.rb

@@ -8,7 +8,7 @@ module Phillumeny
 
     MAJOR      = 0
     MINOR      = 2
-    PATCH      = 0
+    PATCH      = 1
     PRERELEASE = nil
     # PRERELEASE = 'alpha'.freeze
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phillumeny
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Michael Deering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-25 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -47,6 +47,10 @@ extra_rdoc_files: []
 files:
 - lib/phillumeny.rb
 - lib/phillumeny/active_model.rb
+- lib/phillumeny/active_model/validate_presence_of_any.rb
+- lib/phillumeny/active_record.rb
+- lib/phillumeny/active_record/cover_query_with_indexes.rb
+- lib/phillumeny/active_record/have_default_value_of.rb
 - lib/phillumeny/factory_bot.rb
 - lib/phillumeny/version.rb
 homepage: https://github.com/mdeering/phillumeny
@@ -68,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Collection of RSpec matchers for verbose testers.