mil_friendly_id 4.0.9.8

data/test/history_test.rb

@@ -0,0 +1,149 @@
+require "helper"
+
+class Manual < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :history
+end
+
+class HistoryTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  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.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.save!
+      begin
+        assert model_class.find(old_friendly_id)
+        assert model_class.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
+      record = model_class.create! :name => "hello"
+      assert_equal 1, FriendlyId::Slug.count
+      record = model_class.find("hello")
+      record.name = "hello again"
+      record.save!
+      assert_equal 2, FriendlyId::Slug.count
+    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.find(old_friendly_id).readonly?
+    end
+  end
+
+  test "should create correct sequence numbers even when some conflicted slugs have changed" do
+    transaction do
+      record1 = model_class.create! :name => 'hello'
+      record2 = model_class.create! :name => 'hello!'
+      record2.update_attributes :name => 'goodbye'
+      record3 = model_class.create! :name => 'hello!'
+      assert_equal 'hello--3', record3.slug
+    end
+  end
+
+
+  test "should raise error if used with scoped" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      extend FriendlyId
+    end
+    assert_raises RuntimeError do
+      model_class.friendly_id :name, :use => [:history, :scoped]
+    end
+  end
+
+  test "should handle renames" do
+    with_instance_of(model_class) do |record|
+      record.name = 'x'
+      assert record.save
+      record.name = 'y'
+      assert record.save
+      record.name = 'x'
+      assert record.save
+    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 second_record.slug == "foo--2"
+    end
+  end
+
+  test 'should increment the sequence by one for each historic slug' do
+    transaction do
+      previous_record = model_class.create! :name => "foo"
+      first_record = model_class.create! :name => 'another'
+      second_record = model_class.create! :name => 'another'
+      assert second_record.slug == "another--2"
+    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_attributes :name => 'foo'
+      assert second_record.slug == "foo--2"
+      first_record.update_attributes :name => 'another'
+      assert first_record.slug == "another--2"
+    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

data/test/object_utils_test.rb

@@ -0,0 +1,28 @@
+require "helper"
+
+
+class ObjectUtilsTest < MiniTest::Unit::TestCase
+
+  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_equal nil, "1".friendly_id?
+    assert_equal nil, "1".unfriendly_id?
+  end
+
+  test "ActiveRecord::Base instances should be unfriendly_ids" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      self.table_name = "authors"
+    end
+    assert model_class.new.unfriendly_id?
+  end
+end

data/test/reserved_test.rb

@@ -0,0 +1,40 @@
+require "helper"
+
+class ReservedTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name
+
+    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
+  end
+
+  def model_class
+    Journalist
+  end
+
+  test "should reserve 'new' and 'edit' by default" do
+    %w(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
+
+end

data/test/schema.rb

@@ -0,0 +1,79 @@
+require "friendly_id/migration"
+require "globalize3"
+
+class TranslatedArticle < ActiveRecord::Base
+  translates :slug, :title
+end
+
+module FriendlyId
+  module Test
+    class Schema < ActiveRecord::Migration
+      class << self
+        def down
+          CreateFriendlyIdSlugs.down
+          tables.each do |name|
+            drop_table name
+          end
+          TranslatedArticle.drop_translation_table!
+        end
+
+        def up
+          # TODO: use schema version to avoid ugly hacks like this
+          return if @done
+          CreateFriendlyIdSlugs.up
+
+          tables.each do |table_name|
+            create_table table_name do |t|
+              t.string  :name
+              t.boolean :active
+            end
+          end
+
+          slugged_tables.each do |table_name|
+            add_column table_name, :slug, :string
+            add_index  table_name, :slug, :unique => true
+          end
+
+          # This will be used to test scopes
+          add_column :novels, :novelist_id, :integer
+          add_column :novels, :publisher_id, :integer
+          remove_index :novels, :slug
+          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
+
+          # This will be used to test globalize translations
+          TranslatedArticle.create_translation_table! :slug => :string, :title => :string
+
+          # This will be used to test relationships
+          add_column :books, :author_id, :integer
+
+          @done = true
+        end
+
+        private
+
+        def slugged_tables
+          %w[journalists articles novelists novels manuals translated_articles]
+        end
+
+        def simple_tables
+          %w[authors books publishers]
+        end
+
+        def tables
+          simple_tables + slugged_tables
+        end
+      end
+    end
+  end
+end

data/test/scoped_test.rb

@@ -0,0 +1,83 @@
+require "helper"
+
+class Novelist < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged
+end
+
+class Novel < ActiveRecord::Base
+  extend FriendlyId
+  belongs_to :novelist
+  belongs_to :publisher
+  friendly_id :name, :use => :scoped, :scope => [:publisher, :novelist]
+end
+
+class Publisher < ActiveRecord::Base
+  has_many :novels
+end
+
+class ScopedTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  def model_class
+    Novel
+  end
+
+  test "should detect scope column from belongs_to relation" do
+    assert_equal ["publisher_id", "novelist_id"], Novel.friendly_id_config.scope_columns
+  end
+
+  test "should detect scope column from explicit column name" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      extend FriendlyId
+      friendly_id :empty, :use => :scoped, :scope => :dummy
+    end
+    assert_equal ["dummy"], model_class.friendly_id_config.scope_columns
+  end
+
+  test "should allow duplicate slugs outside scope" do
+    transaction do
+      novel1 = Novel.create! :name => "a", :novelist => Novelist.create!(:name => "a")
+      novel2 = Novel.create! :name => "a", :novelist => Novelist.create!(:name => "b")
+      assert_equal novel1.friendly_id, novel2.friendly_id
+    end
+  end
+
+  test "should not allow duplicate slugs inside scope" do
+    with_instance_of Novelist do |novelist|
+      novel1 = Novel.create! :name => "a", :novelist => novelist
+      novel2 = Novel.create! :name => "a", :novelist => novelist
+      assert novel1.friendly_id != novel2.friendly_id
+    end
+  end
+
+  test "should raise error if used with history" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      extend FriendlyId
+    end
+
+    assert_raises RuntimeError do
+      model_class.friendly_id :name, :use => [:scoped, :history]
+    end
+  end
+
+  test "should apply scope with multiple columns" do
+    transaction do
+      novelist = Novelist.create! :name => "a"
+      publisher = Publisher.create! :name => "b"
+
+      novel1 = Novel.create! :name => "c", :novelist => novelist, :publisher => publisher
+      novel2 = Novel.create! :name => "c", :novelist => novelist, :publisher => Publisher.create(:name => "d")
+      novel3 = Novel.create! :name => "c", :novelist => Novelist.create(:name => "e"), :publisher => publisher
+      novel4 = Novel.create! :name => "c", :novelist => novelist, :publisher => publisher
+
+      assert_equal novel1.friendly_id, novel2.friendly_id
+      assert_equal novel2.friendly_id, novel3.friendly_id
+      assert novel3.friendly_id != novel4.friendly_id
+    end
+  end
+end

data/test/shared.rb

@@ -0,0 +1,156 @@
+module FriendlyId
+  module Test
+    module Shared
+
+      module Slugged
+        test "configuration should have a sequence_separator" do
+          assert !model_class.friendly_id_config.sequence_separator.empty?
+        end
+
+        test "should make a new slug if the friendly_id method value has changed" do
+          with_instance_of model_class do |record|
+            record.name = "Changed Value"
+            record.save!
+            assert_equal "changed-value", record.slug
+          end
+        end
+
+        test "should increment the slug sequence for duplicate friendly ids" do
+          with_instance_of model_class do |record|
+            record2 = model_class.create! :name => record.name
+            assert record2.friendly_id.match(/2\z/)
+          end
+        end
+
+        test "should not add slug sequence on update after other conflicting slugs were added" do
+          with_instance_of model_class do |record|
+            old = record.friendly_id
+            model_class.create! :name => record.name
+            record.save!
+            record.reload
+            assert_equal old, record.to_param
+          end
+        end
+
+        test "should not increment sequence on save" do
+          with_instance_of model_class do |record|
+            record2 = model_class.create! :name => record.name
+            record2.active = !record2.active
+            record2.save!
+            assert record2.friendly_id.match(/2\z/)
+          end
+        end
+
+        test "should create slug on save if the slug is nil" do
+          with_instance_of model_class do |record|
+            record.slug = nil
+            record.save!
+            assert_nil record.slug
+            record.save!
+            refute_nil record.slug
+          end
+        end
+
+        test "when validations block save, to_param should return friendly_id rather than nil" do
+          my_model_class = Class.new(model_class)
+          self.class.const_set("Foo", my_model_class)
+          with_instance_of my_model_class do |record|
+            record.update_attributes my_model_class.friendly_id_config.slug_column => nil
+            record = my_model_class.find(record.id)
+            record.class.validate Proc.new {errors[:name] = "FAIL"}
+            record.save
+            assert_equal record.to_param, record.friendly_id
+          end
+        end
+
+      end
+
+      module Core
+        test "finds should respect conditions" do
+          with_instance_of(model_class) do |record|
+            assert_raises(ActiveRecord::RecordNotFound) do
+              model_class.where("1 = 2").find record.friendly_id
+            end
+          end
+        end
+
+        test "should be findable by friendly id" do
+          with_instance_of(model_class) {|record| assert model_class.find record.friendly_id}
+        end
+
+        test "should exist? by friendly id" do
+          with_instance_of(model_class) do |record|
+            assert model_class.exists? record.id
+            assert model_class.exists? record.friendly_id
+            assert model_class.exists?({:id => record.id})
+            assert model_class.exists?(['id = ?', record.id])
+            assert !model_class.exists?(record.friendly_id + "-hello")
+            assert !model_class.exists?(0)
+          end
+        end
+
+        test "should be findable by id as integer" do
+          with_instance_of(model_class) {|record| assert model_class.find record.id.to_i}
+        end
+
+        test "should be findable by id as string" do
+          with_instance_of(model_class) {|record| assert model_class.find record.id.to_s}
+        end
+
+        test "should be findable by numeric friendly_id" do
+          with_instance_of(model_class, :name => "206") {|record| assert model_class.find record.friendly_id}
+        end
+
+        test "to_param should return the friendly_id" do
+          with_instance_of(model_class) {|record| assert_equal record.friendly_id, record.to_param}
+        end
+
+        test "should be findable by themselves" do
+          with_instance_of(model_class) {|record| assert_equal record, model_class.find(record)}
+        end
+
+        test "updating record's other values should not change the friendly_id" do
+          with_instance_of model_class do |record|
+            old = record.friendly_id
+            record.update_attributes! :active => false
+            assert model_class.find old
+          end
+        end
+
+        test "instances found by a single id should not be read-only" do
+          with_instance_of(model_class) {|record| assert !model_class.find(record.friendly_id).readonly?}
+        end
+
+        test "failing finds with unfriendly_id should raise errors normally" do
+          assert_raises(ActiveRecord::RecordNotFound) {model_class.find 0}
+        end
+
+        test "should return numeric id if the friendly_id is nil" do
+          with_instance_of(model_class) do |record|
+            record.expects(:friendly_id).returns(nil)
+            assert_equal record.id.to_s, record.to_param
+          end
+        end
+
+        test "should return numeric id if the friendly_id is an empty string" do
+          with_instance_of(model_class) do |record|
+            record.expects(:friendly_id).returns("")
+            assert_equal record.id.to_s, record.to_param
+          end
+        end
+
+        test "should return numeric id if the friendly_id is blank" do
+          with_instance_of(model_class) do |record|
+            record.expects(:friendly_id).returns("  ")
+            assert_equal record.id.to_s, record.to_param
+          end
+        end
+
+        test "should return nil for to_param with a new record" do
+          assert_equal nil, model_class.new.to_param
+        end
+      end
+    end
+  end
+end
+