Back to Repositories

Testing FriendlyId Core Configuration and ActiveRecord Integration in friendly_id

This test suite validates the core functionality of FriendlyId’s configuration and integration with ActiveRecord models. It ensures proper module inclusion, configuration options, and default settings behavior.

Test Coverage Overview

The test suite provides comprehensive coverage of FriendlyId’s fundamental features and integration points with ActiveRecord.

Module inclusion via both extend and include methods
Configuration options using hash parameters
Block-based configuration capabilities
Default settings management
Proper inheritance and module inclusion verification

Implementation Analysis

The testing approach utilizes minitest’s assertion framework to verify FriendlyId’s configuration mechanisms.

Tests employ dynamic class creation using Class.new(ActiveRecord::Base) to isolate each test case and prevent cross-test contamination. The implementation demonstrates both hash-based and block-based configuration patterns specific to Ruby metaprogramming.

Technical Details

Testing Framework: Minitest
Base Class: TestCaseClass with FriendlyId::Test module
Test Environment: Ruby on Rails with ActiveRecord
Configuration Methods: Hash-based and Block-based approaches
Module Extension: Both ‘extend’ and ‘include’ patterns

Best Practices Demonstrated

The test suite exemplifies several testing best practices for Ruby libraries.

Isolated test cases using dynamic class creation
Comprehensive configuration testing
Clean test setup and teardown (ensuring defaults reset)
Clear test naming conventions
Proper assertion usage for behavior verification

norman/friendly_id

test/base_test.rb

            
require "helper"

class CoreTest < TestCaseClass
  include FriendlyId::Test

  test "friendly_id can be added using 'extend'" do
    klass = Class.new(ActiveRecord::Base) do
      extend FriendlyId
    end
    assert klass.respond_to? :friendly_id
  end

  test "friendly_id can be added using 'include'" do
    klass = Class.new(ActiveRecord::Base) do
      include FriendlyId
    end
    assert klass.respond_to? :friendly_id
  end

  test "friendly_id should accept a base and a hash" do
    klass = Class.new(ActiveRecord::Base) do
      self.abstract_class = true
      extend FriendlyId
      friendly_id :foo, use: :slugged, slug_column: :bar
    end
    assert klass < FriendlyId::Slugged
    assert_equal :foo, klass.friendly_id_config.base
    assert_equal :bar, klass.friendly_id_config.slug_column
  end

  test "friendly_id should accept a block" do
    klass = Class.new(ActiveRecord::Base) do
      self.abstract_class = true
      extend FriendlyId
      friendly_id :foo do |config|
        config.use :slugged
        config.base = :foo
        config.slug_column = :bar
      end
    end
    assert klass < FriendlyId::Slugged
    assert_equal :foo, klass.friendly_id_config.base
    assert_equal :bar, klass.friendly_id_config.slug_column
  end

  test "the block passed to friendly_id should be evaluated before arguments" do
    klass = Class.new(ActiveRecord::Base) do
      self.abstract_class = true
      extend FriendlyId
      friendly_id :foo do |config|
        config.base = :bar
      end
    end
    assert_equal :foo, klass.friendly_id_config.base
  end

  test "should allow defaults to be set via a block" do
    FriendlyId.defaults do |config|
      config.base = :foo
    end
    klass = Class.new(ActiveRecord::Base) do
      self.abstract_class = true
      extend FriendlyId
    end
    assert_equal :foo, klass.friendly_id_config.base
  ensure
    FriendlyId.instance_variable_set :@defaults, nil
  end
end