minitest-sequel 0.3.2 → 0.4.0

data/lib/minitest/sequel/columns.rb

@@ -1,160 +1,224 @@
-# require "minitest/sequel"
-
-# reopening to add schema validation functionality
-module Minitest::Assertions
-
-  # Conveniently test your Model definitions as follows:
-  #
-  #     let(:m) { Post.first }
-  #
-  #     it { assert_have_column(m, :title, type: :string, db_type: 'varchar(250)') }
-  #     it { m.must_have_column(:title, type: :string, db_type: 'varchar(250)') }
-  #
-  #     # assert_have_column(<instance>, <column_name>, <options>, <custom_error_message>)
-  #
-  #     # <instance>.must_have_column(<column_name>, <options>, <custom_error_message>)
-  #
-  #
-  # `assert_have_column()` first tests if the column name is defined in the Model and then checks
-  # all passed options. The following options are valid and checked:
-  #
-  #  * :type
-  #  * :db_type
-  #  * :allow_null
-  #  * :max_length
-  #  * :default
-  #  * :primary_key
-  #  * :auto_increment
-  #
-  # In the event the specs differ from the actual database implementation an extensive error
-  # message with the differing option(s) is provided to help speed up debugging the issue:
-  #
-  #     Expected Post model to have column: :title with: \
-  #       { type: 'string', db_type: 'varchar(250)', allow_null: 'false' } \
-  #       but found: { db_type: 'varchar(255)' }
-  #
-  #
-  # **Please NOTE!**
-  #
-  # To test options with a value that is either `nil`, `true` or `false`, please use `:nil`,
-  # `:false` or `:true` and provide numbers as 'strings' instead.
-  #
-  #
-  def assert_have_column(obj, attribute, opts = {}, msg = nil)
-    msg = msg.nil? ? "" : "#{msg}\n"
-    msg << "Expected #{obj.class} model to have column: :#{attribute}"
-    err_msg  = []
-    conf_msg = []
-    # check if column exists
-    dcol = obj.db.schema(obj.class.table_name).detect { |c| c[0] == attribute }
-    matching = !dcol.nil?
-
-    # bail out if no matching column
-    unless matching
-      msg << " but no such column exists"
-      assert(false, msg)
-    end
+# frozen_string_literal: false
+
+require 'minitest/assertions'
+require 'minitest/spec'
+
+# reopening to add validations functionality
+module Minitest
+  # add support for Assert syntax
+  module Assertions
+    # Asserts that a given model has a specific column with optional attribute checks
+    #
+    # @param obj [Object] The model instance to check
+    # @param attribute [Symbol] The name of the column to check
+    # @param opts [Hash] Optional attributes to verify for the column
+    # @param msg [String, nil] Optional custom error message
+    #
+    # @example Basic usage
+    #   let(:m) { Post.first }
+    #   assert_have_column(m, :title, type: :string, db_type: 'varchar(250)')
+    #
+    # @example Using with Spec syntax
+    #   m.must_have_column(:title, type: :string, db_type: 'varchar(250)')
+    #
+    # The method checks if the column exists in the model and then verifies
+    # any provided options. Valid options include:
+    #
+    #  * :type - The Ruby type of the column
+    #  * :db_type - The database-specific type of the column
+    #  * :allow_null - Whether the column allows NULL values
+    #  * :max_length - The maximum length for string-type columns
+    #  * :default - The default value for the column
+    #  * :primary_key - Whether the column is a primary key
+    #  * :auto_increment - Whether the column auto-increments
+    #
+    # If the actual column attributes differ from the specified options,
+    # a detailed error message is provided:
+    #
+    #     Expected Post model to have column: :title with: \
+    #       { type: 'string', db_type: 'varchar(250)', allow_null: 'false' } \
+    #       but found: { db_type: 'varchar(255)' }
+    #
+    # @note When testing for `nil`, `true`, or `false` values, use `:nil`,
+    #   `:true`, or `:false` symbols respectively. For numeric values,
+    #   provide them as strings.
+    #
+    # rubocop:disable Metrics/MethodLength
+    def assert_have_column(obj, attribute, opts = {}, msg = nil)
+      # Prepare the error message
+      msg = build_message_column(obj, attribute, msg)
+
+      # prepare output messages
+      msg_conf = []
+      msg_err = []
+
+      # extract the db table information for the column
+      dbcol = extract_column_info(obj, attribute)
+
+      # set matching status
+      matching = !dbcol.nil?
+
+      # bail if there is no matching column
+      bail_unless_column_exists(dbcol, msg) unless matching
+      # bail if passed options are invalid
+      bail_unless_valid_options(opts, msg)
+
+      # loop through the options passed and check them and report the result
+      opts.each do |key, value|
+        expected = compare_column_attribute(dbcol, key, value)
+        update_messages(msg_conf, msg_err, key, value, dbcol, expected)
+        matching &&= expected
+      end
 
-    # bail out if options provided are invalid
-    val_opts = [:type, :db_type, :allow_null, :max_length, :default, :primary_key, :auto_increment]
-    invalid_opts = opts.keys.reject { |o| val_opts.include?(o) }
-    unless invalid_opts.empty?
-      msg << ", but the following invalid option(s) was found: { "
-      invalid_opts.each { |o| msg << "#{o.inspect}; " }
-      msg << " }. Valid options are: #{val_opts.inspect}"
-      assert(false, msg)
+      msg << " with: { #{msg_conf.join(', ')} } but found: { #{msg_err.join(', ')} }"
+      assert(matching, msg)
     end
-
-    # TODO: simplify this mess. quick fix didn't work, so look at it again when time permits.
-
-    unless opts[:type].nil?
-      expected = (dcol[1][:type].to_s == opts[:type].to_s)
-      conf_msg << "type: '#{opts[:type]}'"
-      unless expected
-        err_msg << "type: '#{dcol[1][:type]}'"
-      end
-      matching &&= expected
+    # rubocop:enable Metrics/MethodLength
+
+    # Asserts that a given model does not have a specific column
+    #
+    # @param obj [Object] The model instance to check
+    # @param attribute [Symbol] The name of the column to check for absence
+    # @param msg [String, nil] Optional custom error message
+    #
+    # @example
+    #   refute_have_column(user, :admin_flag)
+    #
+    def refute_have_column(obj, attribute, msg = nil)
+      # Prepare the error message
+      msg = build_message_column(obj, attribute, msg, refute: true)
+
+      # extract the column information from the database schema
+      dbcol = extract_column_info(obj, attribute)
+
+      # If the column is not found (dcol is nil), the test passes
+      matching = dbcol.nil?
+
+      # Return early if the test passes (column doesn't exist)
+      return if matching
+
+      # If we reach here, it means the column was found when it shouldn't be
+      msg << ' but such a column was found'
+
+      # Assert that matching is true (which it isn't at this point)
+      # This will raise an assertion error with the prepared message
+      assert(matching, msg)
     end
 
-    unless opts[:db_type].nil?
-      expected = (dcol[1][:db_type].to_s == opts[:db_type].to_s)
-      conf_msg << "db_type: '#{opts[:db_type]}'"
-      unless expected
-        err_msg << "db_type: '#{dcol[1][:db_type]}'"
-      end
-      matching &&= expected
+    private
+
+    # Builds an error message for column assertions
+    #
+    # @param obj [Object] The model instance to check
+    # @param attribute [Symbol] The name of the column to check for absence
+    # @param msg [String, nil] Custom error message
+    # @param refute [Boolean] Whether this is for a refutation (default: false)
+    #
+    # @return [String] The formatted error message
+    #
+    def build_message_column(obj, attribute, msg, refute: false)
+      msg = msg.nil? ? '' : "#{msg}\n"
+      msg << "Expected #{obj.class} model to #{refute ? 'NOT ' : ''}have column: :#{attribute}"
     end
 
-    unless opts[:max_length].nil?
-      expected = (dcol[1][:max_length] === opts[:max_length])
-      conf_msg << "max_length: '#{opts[:max_length]}'"
-      unless expected
-        err_msg << "max_length: '#{dcol[1][:max_length]}'"
-      end
-      matching &&= expected
+    # Extracts the column information for a given attribute in the database schema
+    #
+    # @param obj [Object] The model instance to check
+    # @param attribute [Symbol] The name of the column to find
+    #
+    # @return [Array, nil] The column information array if found, nil otherwise
+    #
+    # @example
+    #   extract_column_info(user, :email)
+    #   # => [:email, {:type=>:string, :db_type=>"varchar(255)", :allow_null=>true, ...}]
+    #
+    def extract_column_info(obj, attribute)
+      obj.db.schema(obj.class.table_name).detect { |c| c[0] == attribute }
     end
 
-    unless opts[:allow_null].nil?
-      v = _convert_value(opts[:allow_null])
-      expected = (dcol[1][:allow_null] === v)
-      conf_msg << "allow_null: '#{opts[:allow_null]}'"
-      unless expected
-        err_msg << "allow_null: '#{dcol[1][:allow_null]}'"
-      end
-      matching &&= expected
+    # Bail if the specified column does not exist in the database schema
+    #
+    # @param dcol [Array, nil] The database column information, or nil if the column doesn't exist
+    # @param msg [String] The error message to be displayed if the column doesn't exist
+    #
+    # @raise [Minitest::Assertion] If the column doesn't exist in the database schema
+    #
+    # @example
+    #   bail_unless_column_exists(column_info, error_message)
+    #
+    def bail_unless_column_exists(dbcol, msg)
+      return if dbcol
+
+      msg << ' but no such column exists'
+      assert(false, msg)
     end
 
-    unless opts[:default].nil?
-      v = _convert_value(opts[:default])
-      expected = (dcol[1][:default] === v)
-      conf_msg << "default: '#{opts[:default]}'"
-      unless expected
-        err_msg << "default: '#{dcol[1][:default].inspect}'"
-      end
-      matching &&= expected
-    end
+    # Bail if the options passed to #assert_have_column are invalid
+    #
+    # @param opts [Hash] The options to validate
+    #
+    # @raise [Minitest::Assertion] If any invalid options are found
+    #
+    # @example
+    #   bail_unless_valid_options(type: :string, db_type: 'varchar(255)')
+    #
+    def bail_unless_valid_options(opts, msg)
+      valid_opts = %i[type db_type allow_null default primary_key auto_increment max_length]
+      invalid_opts = opts.keys.reject { |o| valid_opts.include?(o) }
+
+      return if invalid_opts.empty?
+
+      msg << ', but the following invalid option(s) was found: { '
+      msg << invalid_opts.map(&:inspect).join(', ')
+      msg << " }. Valid options are: #{valid_opts.inspect}"
 
-    unless opts[:primary_key].nil?
-      v = _convert_value(opts[:primary_key])
-      expected = (dcol[1][:primary_key] === v)
-      conf_msg << "primary_key: '#{opts[:primary_key]}'"
-      unless expected
-        err_msg << "primary_key: '#{dcol[1][:primary_key]}'"
-      end
-      matching &&= expected
+      assert(false, msg)
     end
 
-    unless opts[:auto_increment].nil?
-      v = _convert_value(opts[:auto_increment])
-      expected = (dcol[1][:auto_increment] === v)
-      conf_msg << "auto_increment: '#{opts[:auto_increment]}'"
-      unless expected
-        err_msg << "auto_increment: '#{dcol[1][:auto_increment]}'"
+    # Compares the actual column attribute with the expected value
+    #
+    # @param dbcol [Array] The database column information
+    # @param key [Symbol] The attribute key to compare
+    # @param value [Object] The expected value for the attribute
+    #
+    # @return [Boolean] True if the attribute matches the expected value, false otherwise
+    #
+    def compare_column_attribute(dbcol, key, value)
+      case key
+      when :type, :db_type
+        dbcol[1][key].to_s == value.to_s
+      when :allow_null, :default, :primary_key, :auto_increment
+        dbcol[1][key] == _convert_value(value)
+      when :max_length
+        dbcol[1][key] == value
       end
-      matching &&= expected
     end
 
-    msg = msg << " with: { #{conf_msg.join(', ')} } but found: { #{err_msg.join(', ')} }"
-    assert(matching, msg)
-  end
-
-  #
-  def refute_have_column(obj, attribute, msg = nil)
-    msg = msg.nil? ? "" : "#{msg}\n"
-    msg << "Expected #{obj.class} model to NOT have column: :#{attribute}"
-    # check if column exists
-    dcol = obj.db.schema(obj.class.table_name).detect { |col| col[0] == attribute }
-    matching = dcol.nil?
-    unless matching
-      msg << " but such a column was found"
-      assert(matching, msg)
+    # Updates the confirmation and error messages based on column attribute comparison
+    #
+    # @param msg_conf [Array] Array to store confirmation messages
+    # @param msg_err [Array] Array to store error messages
+    # @param key [Symbol] The attribute key being compared
+    # @param value [Object] The expected value for the attribute
+    # @param dbcol [Array] The database column information
+    # @param expected [Boolean] Whether the attribute matches the expected value
+    #
+    # @example
+    #   update_messages(msg_conf, msg_err, :type, 'string', column_info, true)
+    #
+    # rubocop:disable Metrics/ParameterLists
+    def update_messages(msg_conf, msg_err, key, value, dbcol, expected)
+      msg_conf << "#{key}: '#{value}'"
+      val = key == 'default' ? dbcol[1][key].inspect : dbcol[1][key]
+      msg_err << "#{key}: '#{val}'" unless expected
     end
+    # rubocop:enable Metrics/ParameterLists
   end
+  # /module Assertions
 
-end
-
-# add support for Spec syntax
-module Minitest::Expectations
-  infect_an_assertion :assert_have_column, :must_have_column, :reverse
-  infect_an_assertion :refute_have_column, :wont_have_column, :reverse
+  # add support for Spec syntax
+  module Expectations
+    infect_an_assertion :assert_have_column, :must_have_column, :reverse
+    infect_an_assertion :refute_have_column, :wont_have_column, :reverse
+  end
 end

data/lib/minitest/sequel/helpers.rb

@@ -1,7 +1,150 @@
-# require "minitest/sequel"
+# frozen_string_literal: false
+
+require 'minitest/assertions'
+require 'minitest/spec'
+
+# reopening to add validations functionality
+module Minitest
+  # add support for Assert syntax
+  module Assertions
+    # Asserts that a model can be created successfully.
+    #
+    # @param model [Class] The model class to test.
+    #
+    # This method attempts to create a new instance of the given model
+    # using the :make method (typically provided by a factory).
+    # It then asserts that:
+    # 1. The created instance is of the correct type.
+    # 2. The instance has no errors after creation.
+    #
+    # @raise [Minitest::Assertion] If the assertions fail.
+    #
+    def assert_crud_can_create(model)
+      m = model.send(:make)
+
+      msg = "CRUD:create - expected #{m.class} to be an instance of #{model}"
+      assert_instance_of(model, m, msg)
+
+      msg = "CRUD:create - expected .errors to be empty, but was: [#{m.errors.inspect}]"
+      assert_empty(m.errors, msg)
+    end
+
+    # Asserts that a model can be read successfully.
+    #
+    # @param model [Class] The model class to test.
+    #
+    # This method attempts to create a new instance of the given model
+    # using the :make method, then retrieves the first record from the database.
+    # It then asserts that:
+    # 1. The created instance is of the correct type.
+    # 2. The retrieved record is equal to the created instance.
+    #
+    # @raise [Minitest::Assertion] If the assertions fail.
+    #
+    def assert_crud_can_read(model)
+      m = model.send(:make)
+      res = model.send(:first)
+
+      msg = "CRUD:read - expected #{res.class} to be an instance of #{model}"
+      assert_instance_of(model, m, msg)
+
+      assert_equal(m, res, "CRUD:read - expected [#{m.inspect}] to equal [#{res.inspect}]")
+    end
+
+    # Asserts that a model can be updated successfully.
+    #
+    # @param model [Class] The model class to test.
+    # @param attr [Symbol, String] The attribute to update.
+    #
+    # This method attempts to create a new instance of the given model,
+    # update a specific attribute, and then verify the update.
+    #
+    # @raise [Minitest::Assertion] If the assertions fail.
+    #
+    def assert_crud_can_update(model, attr)
+      # Create a new instance of the model
+      m = model.send(:make)
+
+      # Generate a new value for the attribute by appending " Updated" to its current value
+      tmp_str = "#{m.send(attr.to_sym)} Updated"
+
+      # Retrieve the first record from the database
+      res = model.send(:first)
+
+      # Assert that the retrieved record matches the created instance
+      assert_equal(m, res, "CRUD:update - expected [#{m.inspect}] to equal [#{res.inspect}]")
+
+      # Update the attribute with the new value
+      res.send(:"#{attr}=", tmp_str)
+      res.save
+
+      # Retrieve the updated record from the database
+      res2 = model.send(:first)
+
+      # Assert that the updated attribute matches the new value
+      msg = "CRUD:update - expected [#{res2.send(attr.to_sym)}] to equal "
+      msg << "the updated string: [#{tmp_str}]"
+
+      assert_equal(tmp_str, res2.send(attr.to_sym), msg)
+    end
+
+    # Asserts that a model can be destroyed successfully.
+    #
+    # @param model [Class] The model class to test.
+    #
+    # This method tests the destroy functionality of a model, considering both
+    # hard delete and soft delete (using :deleted_at) scenarios.
+    #
+    # @raise [Minitest::Assertion] If the assertions fail.
+    #
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def assert_crud_can_destroy(model)
+      # Create a new instance of the model
+      m = model.send(:make)
+
+      # 1. test for Paranoid plugin
+      plugs = model.instance_variable_get(:@plugins).map(&:to_s)
+      paranoid = plugs.include?('Sequel::Plugins::Paranoid')
+
+      if paranoid
+        # If the model uses soft delete (has :deleted_at), ensure it's initially nil
+        msg = "CRUD:destroy - expected :deleted_at to be nil, but was [#{m.deleted_at}]"
+        assert_nil(m.deleted_at, msg)
+
+        assert(m.soft_delete, 'CRUD:soft_delete - expected m.soft_delete to return true')
+
+        # For soft delete, :deleted_at should be set to a timestamp
+        refute_nil(m.deleted_at, 'CRUD:destroy - expected m.deleted_at to be NOT be nil')
+
+        msg = 'CRUD:destroy - expected m.deleted_at to be an instance of Time'
+        assert_instance_of(Time, m.deleted_at, msg)
+      else
+        # Attempt to destroy the model instance
+        assert(m.destroy, 'CRUD:destroy - expected m.destroy to return true')
+      end
+
+      # Try to retrieve the first record from the database after destruction
+      res = model.send(:first)
+
+      if paranoid
+        # By default the paranoid record should be returned from the database
+        msg = "CRUD:destroy - expected #{model}.first to NOT return nil, but was: [#{res.inspect}]"
+        refute_nil(res, msg)
+      else
+        # By default the record should not be returned from the database
+        msg = "CRUD:destroy - expected #{model}.first to return nil, but was: [#{res.inspect}]"
+        assert_nil(res, msg)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+  # /module Assertions
+end
 
 # reopening to add helpers functionality
-class Minitest::Spec
+# rubocop:disable Style/ClassAndModuleChildren
+class Minitest::Spec < Minitest::Test
+  # module MinitestSequelCRUD
 
   # Enables quick tests to ensure that the basic CRUD functionality is working correctly for a Model
   #
@@ -19,51 +162,77 @@ class Minitest::Spec
   # this test depends upon being able to create a new model instance for each test via using
   # Sequel Factory's `#make()` method
   #
-  def self.ensure_working_CRUD(model, attr)
-
-    describe "a valid CRUD model" do
-
+  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  def self.ensure_working_crud(model, attr)
+    # rubocop:disable Metrics/BlockLength
+    describe 'a valid CRUD model' do
       it "can create a #{model}" do
         m = model.send(:make)
-        assert_instance_of(_model, m, "CRUD:create - expected #{m.class} to be an instance of #{model}")
-        assert_empty(m.errors, "CRUD:create - expected .errors to be empty, but was: [#{m.errors.inspect}]")
+
+        msg = "CRUD:create - expected #{m.class} to be an instance of #{model}"
+        assert_instance_of(model, m, msg)
+
+        msg = "CRUD:create - expected .errors to be empty, but was: [#{m.errors.inspect}]"
+        assert_empty(m.errors, msg)
       end
 
       it "can read a #{model}" do
         m = model.send(:make)
-        res = model.send :first
-        assert_instance_of(model, m, "CRUD:read - expected #{res.class} to be an instance of #{model}")
-        assert_equal(m, res, "CRUD:read - expected [#{m.inspect}] to equal [#{res.inspect}]")
+        # res = model.send(:where, id: m.id)
+        res = model.send(:first)
+        # res = model[m.id]
+
+        msg = "CRUD:read - expected #{res.class} to be an instance of #{model}"
+        assert_instance_of(model, m, msg)
+
+        msg = "CRUD:read - expected [#{m.inspect}] to equal [#{res.inspect}]"
+        assert_equal(m, res, msg)
       end
 
       it "can update a #{model}" do
         m = model.send(:make)
         tmp_str = "#{m.send(attr.to_sym)} Updated"
         res = model.send(:first)
+        # res = model[m.id]
 
-        assert_equal(m, res, "CRUD:update - expected [#{m.inspect}] to equal [#{res.inspect}]")
-        res.send("#{attr}=", tmp_str)
+        msg = "CRUD:update - expected [#{m.inspect}] to equal [#{res.inspect}]"
+        assert_equal(m, res, msg)
+        res.send(:"#{attr}=", tmp_str)
         res.save
 
         res2 = model.send(:first)
-        assert_equal(tmp_str, res2.send(attr.to_sym), "CRUD:update - expected [#{res2.send(attr.to_sym)}] to equal the updated string: [#{tmp_str}]")
+        # res2 = model[m.id]
+
+        msg = "CRUD:update - expected [#{res2.send(attr.to_sym)}] to equal the "
+        msg << "updated string: [#{tmp_str}]"
+
+        assert_equal(tmp_str, res2.send(attr.to_sym), msg)
       end
 
       it "can destroy a #{model}" do
         m = model.send(:make)
+
         if m.respond_to?(:deleted_at)
-          assert_nil(m.deleted_at, "CRUD:delete - expected m.deleted_at to be nil, but was [#{m.deleted_at}]")
+          msg = "CRUD:delete - expected m.deleted_at to be nil, but was [#{m.deleted_at}]"
+          assert_nil(m.deleted_at, msg)
         end
-        assert(m.destroy, "CRUD:delete - expected m.destroy to return true")
+
+        assert(m.destroy, 'CRUD:delete - expected m.destroy to return true')
         res = model.send(:first)
-        assert_nil(res, "CRUD:delete - expected #{model}.first to return nil, but was: [#{res.inspect}]")
+
         if m.respond_to?(:deleted_at)
-          refute_nil(m.deleted_at, "CRUD:delete - expected m.deleted_at to be NOT be nil")
-          assert_instance_of(Time, m.deleted_at, "CRUD:delete - expected m.deleted_at to be an instance of Time")
+          refute_nil(m.deleted_at, 'CRUD:delete - expected m.deleted_at to be NOT be nil')
+
+          msg = 'CRUD:delete - expected m.deleted_at to be an instance of Time'
+          assert_instance_of(Time, m.deleted_at, msg)
+        else
+          msg = "CRUD:delete - expected #{model}.first to return nil, but was: [#{res.inspect}]"
+          assert_nil(res, msg)
         end
       end
-
     end
+    # rubocop:enable Metrics/BlockLength
   end
-
+  # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 end
+# rubocop:enable Style/ClassAndModuleChildren