friendly_id 5.5.1 → 5.7.0

data/test/history_test.rb

@@ -1,434 +0,0 @@
-require "helper"
-
-class HistoryTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  class Manual < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, use: [:slugged, :history]
-  end
-
-  def model_class
-    Manual
-  end
-
-  test "should insert record in slugs table on create" do
-    with_instance_of(model_class) { |record| assert record.slugs.any? }
-  end
-
-  test "should not create new slug record if friendly_id is not changed" do
-    with_instance_of(model_class) do |record|
-      record.active = true
-      record.save!
-      assert_equal 1, FriendlyId::Slug.count
-    end
-  end
-
-  test "should create new slug record when friendly_id changes" do
-    with_instance_of(model_class) do |record|
-      record.name = record.name + "b"
-      record.slug = nil
-      record.save!
-      assert_equal 2, FriendlyId::Slug.count
-    end
-  end
-
-  test "should be findable by old slugs" do
-    with_instance_of(model_class) do |record|
-      old_friendly_id = record.friendly_id
-      record.name = record.name + "b"
-      record.slug = nil
-      record.save!
-      begin
-        assert model_class.friendly.find(old_friendly_id)
-        assert model_class.friendly.exists?(old_friendly_id), "should exist? by old id"
-      rescue ActiveRecord::RecordNotFound
-        flunk "Could not find record by old id"
-      end
-    end
-  end
-
-  test "should create slug records on each change" do
-    transaction do
-      model_class.create! name: "hello"
-      assert_equal 1, FriendlyId::Slug.count
-
-      record = model_class.friendly.find("hello")
-      record.name = "hello again"
-      record.slug = nil
-      record.save!
-      assert_equal 2, FriendlyId::Slug.count
-    end
-  end
-
-  test "should not be read only when found by slug" do
-    with_instance_of(model_class) do |record|
-      refute model_class.friendly.find(record.friendly_id).readonly?
-      assert record.update name: "foo"
-    end
-  end
-
-  test "should not be read only when found by old slug" do
-    with_instance_of(model_class) do |record|
-      old_friendly_id = record.friendly_id
-      record.name = record.name + "b"
-      record.save!
-      assert !model_class.friendly.find(old_friendly_id).readonly?
-    end
-  end
-
-  test "should handle renames" do
-    with_instance_of(model_class) do |record|
-      record.name = "x"
-      record.slug = nil
-      assert record.save
-      record.name = "y"
-      record.slug = nil
-      assert record.save
-      record.name = "x"
-      record.slug = nil
-      assert record.save
-    end
-  end
-
-  test "should maintain history even if current slug is not the most recent one" do
-    with_instance_of(model_class) do |record|
-      record.name = "current"
-      assert record.save
-
-      # this feels like a hack. only thing i can get to work with the HistoryTestWithSti
-      # test cases. (Editorialist vs Journalist.)
-      sluggable_type = FriendlyId::Slug.first.sluggable_type
-      # create several slugs for record
-      # current slug does not have max id
-      FriendlyId::Slug.delete_all
-      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: "current")
-      FriendlyId::Slug.create(sluggable_type: sluggable_type, sluggable_id: record.id, slug: "outdated")
-
-      record.reload
-      record.slug = nil
-      assert record.save
-
-      assert_equal 2, FriendlyId::Slug.count
-    end
-  end
-
-  test "should not create new slugs that match old slugs" do
-    transaction do
-      first_record = model_class.create! name: "foo"
-      first_record.name = "bar"
-      first_record.save!
-      second_record = model_class.create! name: "foo"
-      assert second_record.slug != "foo"
-      assert_match(/foo-.+/, second_record.slug)
-    end
-  end
-
-  test "should not fail when updating historic slugs" do
-    transaction do
-      first_record = model_class.create! name: "foo"
-      second_record = model_class.create! name: "another"
-
-      second_record.update name: "foo", slug: nil
-      assert_match(/foo-.*/, second_record.slug)
-
-      first_record.update name: "another", slug: nil
-      assert_match(/another-.*/, first_record.slug)
-    end
-  end
-
-  test "should prefer product that used slug most recently" do
-    transaction do
-      first_record = model_class.create! name: "foo"
-      second_record = model_class.create! name: "bar"
-
-      first_record.update! slug: "not_foo"
-      second_record.update! slug: "foo" # now both records have used foo; second_record most recently
-      second_record.update! slug: "not_bar"
-
-      assert_equal model_class.friendly.find("foo"), second_record
-    end
-  end
-
-  test "should name table according to prefix and suffix" do
-    transaction do
-      prefix = "prefix_"
-      without_prefix = FriendlyId::Slug.table_name
-      ActiveRecord::Base.table_name_prefix = prefix
-      FriendlyId::Slug.reset_table_name
-      assert_equal prefix + without_prefix, FriendlyId::Slug.table_name
-    ensure
-      ActiveRecord::Base.table_name_prefix = ""
-      FriendlyId::Slug.table_name = without_prefix
-    end
-  end
-end
-
-class HistoryTestWithAutomaticSlugRegeneration < HistoryTest
-  class Manual < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, use: [:slugged, :history]
-
-    def should_generate_new_friendly_id?
-      slug.blank? or name_changed?
-    end
-  end
-
-  def model_class
-    Manual
-  end
-
-  test "should allow reversion back to a previously used slug" do
-    with_instance_of(model_class, name: "foo") do |record|
-      record.name = "bar"
-      record.save!
-      assert_equal "bar", record.friendly_id
-      record.name = "foo"
-      record.save!
-      assert_equal "foo", record.friendly_id
-    end
-  end
-end
-
-class DependentDestroyTest < TestCaseClass
-  include FriendlyId::Test
-
-  class FalseManual < ActiveRecord::Base
-    self.table_name = "manuals"
-
-    extend FriendlyId
-    friendly_id :name, use: :history, dependent: false
-  end
-
-  class DefaultManual < ActiveRecord::Base
-    self.table_name = "manuals"
-
-    extend FriendlyId
-    friendly_id :name, use: :history
-  end
-
-  test "should allow disabling of dependent destroy" do
-    transaction do
-      assert FriendlyId::Slug.find_by_slug("foo").nil?
-      l = FalseManual.create! name: "foo"
-      assert FriendlyId::Slug.find_by_slug("foo").present?
-      l.destroy
-      assert FriendlyId::Slug.find_by_slug("foo").present?
-    end
-  end
-
-  test "should dependently destroy by default" do
-    transaction do
-      assert FriendlyId::Slug.find_by_slug("baz").nil?
-      l = DefaultManual.create! name: "baz"
-      assert FriendlyId::Slug.find_by_slug("baz").present?
-      l.destroy
-      assert FriendlyId::Slug.find_by_slug("baz").nil?
-    end
-  end
-end
-
-if ActiveRecord::VERSION::STRING >= "5.0"
-  class HistoryTestWithParanoidDeletes < HistoryTest
-    class ParanoidRecord < ActiveRecord::Base
-      extend FriendlyId
-      friendly_id :name, use: :history, dependent: false
-
-      default_scope { where(deleted_at: nil) }
-    end
-
-    def model_class
-      ParanoidRecord
-    end
-
-    test "slug should have a sluggable even when soft deleted by a library" do
-      transaction do
-        assert FriendlyId::Slug.find_by_slug("paranoid").nil?
-        record = model_class.create(name: "paranoid")
-        assert FriendlyId::Slug.find_by_slug("paranoid").present?
-
-        record.update deleted_at: Time.now
-
-        orphan_slug = FriendlyId::Slug.find_by_slug("paranoid")
-        assert orphan_slug.present?, "Orphaned slug should exist"
-
-        assert orphan_slug.valid?, "Errors: #{orphan_slug.errors.full_messages}"
-        assert orphan_slug.sluggable.present?, "Orphaned slug should still find corresponding paranoid sluggable"
-      end
-    end
-  end
-end
-
-class HistoryTestWithSti < HistoryTest
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, use: [:slugged, :history]
-  end
-
-  class Editorialist < Journalist
-  end
-
-  def model_class
-    Editorialist
-  end
-end
-
-class HistoryTestWithFriendlyFinders < HistoryTest
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, use: [:slugged, :finders, :history]
-  end
-
-  class Restaurant < ActiveRecord::Base
-    extend FriendlyId
-    belongs_to :city
-    friendly_id :name, use: [:slugged, :history, :finders]
-  end
-
-  test "should be findable by old slugs" do
-    [Journalist, Restaurant].each do |model_class|
-      with_instance_of(model_class) do |record|
-        old_friendly_id = record.friendly_id
-        record.name = record.name + "b"
-        record.slug = nil
-        record.save!
-        begin
-          assert model_class.find(old_friendly_id)
-          assert model_class.exists?(old_friendly_id), "should exist? by old id for #{model_class.name}"
-        rescue ActiveRecord::RecordNotFound
-          flunk "Could not find record by old id for #{model_class.name}"
-        end
-      end
-    end
-  end
-end
-
-class HistoryTestWithFindersBeforeHistory < HistoryTest
-  class Novelist < ActiveRecord::Base
-    has_many :novels
-  end
-
-  class Novel < ActiveRecord::Base
-    extend FriendlyId
-
-    belongs_to :novelist
-
-    friendly_id :name, use: [:finders, :history]
-
-    def should_generate_new_friendly_id?
-      slug.blank? || name_changed?
-    end
-  end
-
-  test "should be findable by old slug through has_many association" do
-    transaction do
-      novelist = Novelist.create!(name: "Stephen King")
-      novel = novelist.novels.create(name: "Rita Hayworth and Shawshank Redemption")
-      slug = novel.slug
-      novel.name = "Shawshank Redemption"
-      novel.save!
-      assert_equal novel, Novel.find(slug)
-      assert_equal novel, novelist.novels.find(slug)
-    end
-  end
-end
-
-class City < ActiveRecord::Base
-  has_many :restaurants
-end
-
-class Restaurant < ActiveRecord::Base
-  extend FriendlyId
-  belongs_to :city
-  friendly_id :name, use: [:scoped, :history], scope: :city
-end
-
-class ScopedHistoryTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Restaurant
-  end
-
-  test "should find old scoped slugs" do
-    transaction do
-      city = City.create!
-      with_instance_of(Restaurant) do |record|
-        record.city = city
-
-        record.name = "x"
-        record.slug = nil
-        record.save!
-
-        record.name = "y"
-        record.slug = nil
-        record.save!
-
-        assert_equal city.restaurants.friendly.find("x"), city.restaurants.friendly.find("y")
-      end
-    end
-  end
-
-  test "should consider old scoped slugs when creating slugs" do
-    transaction do
-      city = City.create!
-      with_instance_of(Restaurant) do |record|
-        record.city = city
-
-        record.name = "x"
-        record.slug = nil
-        record.save!
-
-        record.name = "y"
-        record.slug = nil
-        record.save!
-
-        second_record = model_class.create! city: city, name: "x"
-        assert_match(/x-.+/, second_record.friendly_id)
-
-        third_record = model_class.create! city: city, name: "y"
-        assert_match(/y-.+/, third_record.friendly_id)
-      end
-    end
-  end
-
-  test "should record history when scope changes" do
-    transaction do
-      city1 = City.create!
-      city2 = City.create!
-      with_instance_of(Restaurant) do |record|
-        record.name = "x"
-        record.slug = nil
-
-        record.city = city1
-        record.save!
-        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
-        assert_equal("x", record.slugs.reload.first.slug)
-
-        record.city = city2
-        record.save!
-        assert_equal("city_id:#{city2.id}", record.slugs.reload.first.scope)
-
-        record.name = "y"
-        record.slug = nil
-        record.city = city1
-        record.save!
-        assert_equal("city_id:#{city1.id}", record.slugs.reload.first.scope)
-        assert_equal("y", record.slugs.reload.first.slug)
-      end
-    end
-  end
-
-  test "should allow equal slugs in different scopes" do
-    transaction do
-      city = City.create!
-      second_city = City.create!
-      record = model_class.create! city: city, name: "x"
-      second_record = model_class.create! city: second_city, name: "x"
-
-      assert_equal record.slug, second_record.slug
-    end
-  end
-end

data/test/numeric_slug_test.rb

@@ -1,31 +0,0 @@
-require "helper"
-
-class NumericSlugTest < TestCaseClass
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-
-  def model_class
-    Article
-  end
-
-  test "should generate numeric slugs" do
-    transaction do
-      record = model_class.create! name: "123"
-      assert_equal "123", record.slug
-    end
-  end
-
-  test "should find by numeric slug" do
-    transaction do
-      record = model_class.create! name: "123"
-      assert_equal model_class.friendly.find("123").id, record.id
-    end
-  end
-
-  test "should exist? by numeric slug" do
-    transaction do
-      model_class.create! name: "123"
-      assert model_class.friendly.exists?("123")
-    end
-  end
-end

data/test/object_utils_test.rb

@@ -1,27 +0,0 @@
-require "helper"
-
-class ObjectUtilsTest < TestCaseClass
-  include FriendlyId::Test
-
-  test "strings with letters are friendly_ids" do
-    assert "a".friendly_id?
-  end
-
-  test "integers should be unfriendly ids" do
-    assert 1.unfriendly_id?
-  end
-
-  test "numeric strings are neither friendly nor unfriendly" do
-    assert_nil "1".friendly_id?
-    assert_nil "1".unfriendly_id?
-  end
-
-  test "ActiveRecord::Base instances should be unfriendly_ids" do
-    FriendlyId.mark_as_unfriendly(ActiveRecord::Base)
-
-    model_class = Class.new(ActiveRecord::Base) do
-      self.table_name = "authors"
-    end
-    assert model_class.new.unfriendly_id?
-  end
-end

data/test/reserved_test.rb

@@ -1,73 +0,0 @@
-require "helper"
-
-class ReservedTest < TestCaseClass
-  include FriendlyId::Test
-
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :slug_candidates, use: [:slugged, :reserved], reserved_words: %w[new edit]
-
-    after_validation :move_friendly_id_error_to_name
-
-    def move_friendly_id_error_to_name
-      errors.add :name, *errors.delete(:friendly_id) if errors[:friendly_id].present?
-    end
-
-    def slug_candidates
-      name
-    end
-  end
-
-  def model_class
-    Journalist
-  end
-
-  test "should reserve words" do
-    %w[new edit NEW Edit].each do |word|
-      transaction do
-        assert_raises(ActiveRecord::RecordInvalid) { model_class.create! name: word }
-      end
-    end
-  end
-
-  test "should move friendly_id error to name" do
-    with_instance_of(model_class) do |record|
-      record.errors.add :name, "xxx"
-      record.errors.add :friendly_id, "yyy"
-      record.move_friendly_id_error_to_name
-      assert record.errors[:name].present? && record.errors[:friendly_id].blank?
-      assert_equal 2, record.errors.count
-    end
-  end
-
-  test "should reject reserved candidates" do
-    transaction do
-      record = model_class.new(name: "new")
-      def record.slug_candidates
-        [:name, "foo"]
-      end
-      record.save!
-      assert_equal "foo", record.friendly_id
-    end
-  end
-
-  test "should be invalid if all candidates are reserved" do
-    transaction do
-      record = model_class.new(name: "new")
-      def record.slug_candidates
-        ["edit", "new"]
-      end
-      assert_raises(ActiveRecord::RecordInvalid) { record.save! }
-    end
-  end
-
-  test "should optionally treat reserved words as conflict" do
-    klass = Class.new(model_class) do
-      friendly_id :slug_candidates, use: [:slugged, :reserved], reserved_words: %w[new edit], treat_reserved_as_conflict: true
-    end
-
-    with_instance_of(klass, name: "new") do |record|
-      assert_match(/new-([0-9a-z]+-){4}[0-9a-z]+\z/, record.slug)
-    end
-  end
-end

data/test/schema.rb

@@ -1,117 +0,0 @@
-require "friendly_id/migration"
-
-module FriendlyId
-  module Test
-    migration_class =
-      if ActiveRecord::VERSION::MAJOR >= 5
-        ActiveRecord::Migration[4.2]
-      else
-        ActiveRecord::Migration
-      end
-
-    class Schema < migration_class
-      class << self
-        def down
-          CreateFriendlyIdSlugs.down
-          tables.each do |name|
-            drop_table name
-          end
-        end
-
-        def up
-          # TODO: use schema version to avoid ugly hacks like this
-          return if @done
-          CreateFriendlyIdSlugs.migrate :up
-
-          tables.each do |table_name|
-            create_table table_name do |t|
-              t.string :name
-              t.boolean :active
-            end
-          end
-
-          tables_with_uuid_primary_key.each do |table_name|
-            create_table table_name, primary_key: :uuid_key, id: false do |t|
-              t.string :name
-              t.string :uuid_key, null: false
-              t.string :slug
-            end
-            add_index table_name, :slug, unique: true
-          end
-
-          slugged_tables.each do |table_name|
-            add_column table_name, :slug, :string
-            add_index table_name, :slug, unique: true if table_name != "novels"
-          end
-
-          scoped_tables.each do |table_name|
-            add_column table_name, :slug, :string
-          end
-
-          paranoid_tables.each do |table_name|
-            add_column table_name, :slug, :string
-            add_column table_name, :deleted_at, :datetime
-            add_index table_name, :deleted_at
-          end
-
-          # This will be used to test scopes
-          add_column :novels, :novelist_id, :integer
-          add_column :novels, :publisher_id, :integer
-          add_index :novels, [:slug, :publisher_id, :novelist_id], unique: true
-
-          # This will be used to test column name quoting
-          add_column :journalists, "strange name", :string
-
-          # This will be used to test STI
-          add_column :journalists, "type", :string
-
-          # These will be used to test i18n
-          add_column :journalists, "slug_en", :string
-          add_column :journalists, "slug_es", :string
-          add_column :journalists, "slug_de", :string
-          add_column :journalists, "slug_fr_ca", :string
-
-          # This will be used to test relationships
-          add_column :books, :author_id, :integer
-
-          # Used to test :scoped and :history together
-          add_column :restaurants, :city_id, :integer
-
-          # Used to test candidates
-          add_column :cities, :code, :string, limit: 3
-
-          # Used as a non-default slug_column
-          add_column :authors, :subdomain, :string
-
-          @done = true
-        end
-
-        private
-
-        def slugged_tables
-          %w[journalists articles novelists novels manuals cities]
-        end
-
-        def paranoid_tables
-          ["paranoid_records"]
-        end
-
-        def tables_with_uuid_primary_key
-          ["menu_items"]
-        end
-
-        def scoped_tables
-          ["restaurants"]
-        end
-
-        def simple_tables
-          %w[authors books publishers]
-        end
-
-        def tables
-          simple_tables + slugged_tables + scoped_tables + paranoid_tables
-        end
-      end
-    end
-  end
-end