friendly_id 3.3.3.0 → 4.0.0.beta7

data/test/history_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+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.empty?}
+  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!
+      assert found = model_class.find_by_friendly_id(old_friendly_id)
+      assert !found.readonly?
+    end
+  end
+
+  test "should raise error if used with scoped" do
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.extend FriendlyId
+    assert_raises RuntimeError do
+      model_class.friendly_id :name, :use => [:history, :scoped]
+    end
+  end
+
+end

data/test/object_utils_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+
+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)
+    model_class.table_name = "authors"
+    assert model_class.new.unfriendly_id?
+  end
+end

data/test/reserved_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+class ReservedTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name
+  end
+
+
+  def model_class
+    Journalist
+  end
+
+  test "should reserve 'new' and 'edit' by default" do
+    ["new", "edit"].each do |word|
+      transaction do
+        assert_raises(ActiveRecord::RecordInvalid) {model_class.create! :name => word}
+      end
+    end
+  end
+end
+
+

data/test/schema.rb

@@ -0,0 +1,59 @@
+require "friendly_id/migration"
+
+module FriendlyId
+  module Test
+    class Schema < ActiveRecord::Migration
+      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.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
+          remove_index :novels, :slug
+
+          # 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
+          @done = true
+        end
+
+        private
+
+        def slugged_tables
+          ["journalists", "articles", "novelists", "novels", "manuals"]
+        end
+
+        def simple_tables
+          ["authors", "books"]
+        end
+
+        def tables
+          simple_tables + slugged_tables
+        end
+      end
+    end
+  end
+end

data/test/scoped_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../helper", __FILE__)
+
+class Novelist < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged
+end
+
+class Novel < ActiveRecord::Base
+  extend FriendlyId
+  belongs_to :novelist
+  friendly_id :name, :use => :scoped, :scope => :novelist
+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 "novelist_id", Novel.friendly_id_config.scope_column
+  end
+
+  test "should detect scope column from explicit column name" do
+    model_class = Class.new(ActiveRecord::Base)
+    model_class.extend FriendlyId
+    model_class.friendly_id :empty, :use => :scoped, :scope => :dummy
+    assert_equal "dummy", model_class.friendly_id_config.scope_column
+  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)
+    model_class.extend FriendlyId
+    assert_raises RuntimeError do
+      model_class.friendly_id :name, :use => [:scoped, :history]
+    end
+  end
+end

data/test/shared.rb

@@ -0,0 +1,118 @@
+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
+            record2 = 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
+      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 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
+      end
+    end
+  end
+end
+

data/test/slugged_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+Journalist, Article = 2.times.map do
+  Class.new(ActiveRecord::Base) do
+    extend FriendlyId
+    friendly_id :name, :use => :slugged
+  end
+end
+
+class SluggedTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+  include FriendlyId::Test::Shared::Slugged
+
+  def model_class
+    Journalist
+  end
+end
+
+class SlugSequencerTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  test "should quote column names" do
+    model_class            = Class.new(ActiveRecord::Base)
+    model_class.table_name = "journalists"
+    model_class.extend FriendlyId
+    model_class.friendly_id :name, :use => :slugged, :slug_column => "strange name"
+    begin
+      with_instance_of(model_class) {|record| assert model_class.find(record.friendly_id)}
+    rescue ActiveRecord::StatementInvalid
+      flunk "column name was not quoted"
+    end
+  end
+end
+
+class SlugSeparatorTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :slugged, :sequence_separator => ":"
+  end
+
+  def model_class
+    Journalist
+  end
+
+  test "should increment sequence with configured sequence separator" 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 detect when a sequenced slug has changed" do
+    with_instance_of model_class do |record|
+      record2 = model_class.create! :name => record.name
+      assert !record2.slug_sequencer.slug_changed?
+      record2.name = "hello world"
+      assert record2.slug_sequencer.slug_changed?
+    end
+  end
+end
+
+class SluggedRegressionsTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  def model_class
+    Journalist
+  end
+
+  test "should increment the slug sequence for duplicate friendly ids beyond 10" do
+    with_instance_of model_class do |record|
+      (2..12).each do |i|
+        r = model_class.create! :name => record.name
+        assert r.friendly_id.match(/#{i}\z/)
+      end
+    end
+  end
+end

data/test/sti_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+class StiTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+  include FriendlyId::Test::Shared::Slugged
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :slugged
+  end
+
+  class Editorialist < Journalist
+  end
+
+  def model_class
+    Editorialist
+  end
+
+  test "friendly_id should accept a base and a hash with single table inheritance" do
+    abstract_klass = Class.new(ActiveRecord::Base) do
+      extend FriendlyId
+      friendly_id :foo, :use => :slugged, :slug_column => :bar
+    end
+    klass = Class.new(abstract_klass)
+    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 with single table inheritance" do
+    abstract_klass = Class.new(ActiveRecord::Base) do
+      extend FriendlyId
+      friendly_id :foo do |config|
+        config.use :slugged
+        config.base = :foo
+        config.slug_column = :bar
+      end
+    end
+    klass = Class.new(abstract_klass)
+    assert klass < FriendlyId::Slugged
+    assert_equal :foo, klass.friendly_id_config.base
+    assert_equal :bar, klass.friendly_id_config.slug_column
+  end
+
+end