geothird_friendly_id 4.0.9.1

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
+

data/test/simple_i18n_test.rb

@@ -0,0 +1,133 @@
+require "helper"
+
+class SimpleI18nTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :simple_i18n
+  end
+
+  def setup
+    I18n.locale = :en
+  end
+
+  test "friendly_id should return the current locale's slug" do
+    journalist = Journalist.new(:name => "John Doe")
+    journalist.slug_es = "juan-fulano"
+    journalist.valid?
+    I18n.with_locale(I18n.default_locale) do
+      assert_equal "john-doe", journalist.friendly_id
+    end
+    I18n.with_locale(:es) do
+      assert_equal "juan-fulano", journalist.friendly_id
+    end
+  end
+
+  test "should create record with slug in column for the current locale" do
+    I18n.with_locale(I18n.default_locale) do
+      journalist = Journalist.new(:name => "John Doe")
+      journalist.valid?
+      assert_equal "john-doe", journalist.slug_en
+      assert_nil journalist.slug_es
+    end
+    I18n.with_locale(:es) do
+      journalist = Journalist.new(:name => "John Doe")
+      journalist.valid?
+      assert_equal "john-doe", journalist.slug_es
+      assert_nil journalist.slug_en
+    end
+  end
+
+  test "to_param should return the numeric id when there's no slug for the current locale" do
+    transaction do
+      journalist = Journalist.new(:name => "Juan Fulano")
+      I18n.with_locale(:es) do
+        journalist.save!
+        assert_equal "juan-fulano", journalist.to_param
+      end
+      assert_equal journalist.id.to_s, journalist.to_param
+    end
+  end
+
+  test "should set friendly id for locale" do
+    transaction do
+      journalist = Journalist.create!(:name => "John Smith")
+      journalist.set_friendly_id("Juan Fulano", :es)
+      journalist.save!
+      assert_equal "juan-fulano", journalist.slug_es
+      I18n.with_locale(:es) do
+        assert_equal "juan-fulano", journalist.to_param
+      end
+    end
+  end
+
+  test "set friendly_id should fall back default locale when none is given" do
+    transaction do
+      journalist = I18n.with_locale(:es) do
+        Journalist.create!(:name => "Juan Fulano")
+      end
+      journalist.set_friendly_id("John Doe")
+      journalist.save!
+      assert_equal "john-doe", journalist.slug_en
+    end
+  end
+
+  test "should sequence localized slugs" do
+    transaction do
+      journalist = Journalist.create!(:name => "John Smith")
+      I18n.with_locale(:es) do
+        Journalist.create!(:name => "Juan Fulano")
+      end
+      journalist.set_friendly_id("Juan Fulano", :es)
+      journalist.save!
+      assert_equal "john-smith", journalist.to_param
+      I18n.with_locale(:es) do
+        assert_equal "juan-fulano--2", journalist.to_param
+      end
+    end
+  end
+
+  class RegressionTest < MiniTest::Unit::TestCase
+    include FriendlyId::Test
+
+    test "should not overwrite slugs on update_attributes" do
+      transaction do
+        journalist = Journalist.create!(:name => "John Smith")
+        journalist.set_friendly_id("Juan Fulano", :es)
+        journalist.save!
+        assert_equal "john-smith", journalist.to_param
+        journalist.update_attributes :name => "Johnny Smith"
+        assert_equal "johnny-smith", journalist.to_param
+        I18n.with_locale(:es) do
+          assert_equal "juan-fulano", journalist.to_param
+        end
+      end
+    end
+  end
+
+  class ConfigurationTest < MiniTest::Unit::TestCase
+    test "should add locale to slug column for a non-default locale" do
+      I18n.with_locale :es do
+        assert_equal "slug_es", Journalist.friendly_id_config.slug_column
+      end
+    end
+
+    test "should add locale to non-default slug column and non-default locale" do
+      model_class = Class.new(ActiveRecord::Base) do
+        self.abstract_class = true
+        extend FriendlyId
+        friendly_id :name, :use => :simple_i18n, :slug_column => :foo
+      end
+      I18n.with_locale :es do
+        assert_equal "foo_es", model_class.friendly_id_config.slug_column
+      end
+    end
+
+    test "should add locale to slug column for default locale" do
+      I18n.with_locale(I18n.default_locale) do
+        assert_equal "slug_en", Journalist.friendly_id_config.slug_column
+      end
+    end
+  end
+end

data/test/slugged_test.rb

@@ -0,0 +1,280 @@
+require "helper"
+
+class Journalist < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged
+end
+
+class Article < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged
+end
+
+class Novelist < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name, :use => :slugged, :sequence_separator => '_'
+
+  def normalize_friendly_id(string)
+    super.gsub("-", "_")
+  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
+
+  test "should not allow reserved words in resulting slug" do
+    ["new", "New", "NEW"].each do |word|
+      transaction do
+        assert_raises(ActiveRecord::RecordInvalid) {model_class.create! :name => word}
+      end
+    end
+  end
+
+  test "should allow validations on the slug" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "articles"
+      extend FriendlyId
+      friendly_id :name, :use => :slugged
+      validates_length_of :slug, :maximum => 1
+      def self.name
+        "Article"
+      end
+    end
+    instance = model_class.new :name => "hello"
+    refute instance.valid?
+  end
+
+  test "should allow nil slugs" do
+    transaction do
+      m1 = model_class.create!
+      model_class.create!
+      assert_nil m1.slug
+    end
+  end
+
+  test "should not break validates_uniqueness_of" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "journalists"
+      extend FriendlyId
+      friendly_id :name, :use => :slugged
+      validates_uniqueness_of :slug_en
+      def self.name
+        "Journalist"
+      end
+    end
+    transaction do
+      instance = model_class.create! :name => "hello", :slug_en => "hello"
+      instance2 = model_class.create :name => "hello", :slug_en => "hello"
+      assert instance.valid?
+      refute instance2.valid?
+    end
+  end
+end
+
+class SlugGeneratorTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  def model_class
+    Journalist
+  end
+
+  test "should quote column names" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+      self.table_name = "journalists"
+      extend FriendlyId
+      friendly_id :name, :use => :slugged, :slug_column => "strange name"
+    end
+
+    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
+
+  test "should not resequence lower sequences on update" do
+    transaction do
+      m1 = model_class.create! :name => "a b c d"
+      assert_equal "a-b-c-d", m1.slug
+      model_class.create! :name => "a b c d"
+      m1 = model_class.find(m1.id)
+      m1.save!
+      assert_equal "a-b-c-d", m1.slug
+    end
+  end
+
+  test "should correctly sequence slugs that end with numbers" do
+    transaction do
+      record1 = model_class.create! :name => "Peugeuot 206"
+      assert_equal "peugeuot-206", record1.slug
+      record2 = model_class.create! :name => "Peugeuot 206"
+      assert_equal "peugeuot-206--2", record2.slug
+    end
+  end
+
+  test "should correctly sequence slugs with underscores" do
+    transaction do
+      record1 = Novelist.create! :name => 'wordsfail, buildings tumble'
+      record2 = Novelist.create! :name => 'word fail'
+      assert_equal 'word_fail', record2.slug
+    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.should_generate_new_friendly_id?
+      record2.name = "hello world"
+      assert record2.should_generate_new_friendly_id?
+    end
+  end
+
+  test "should correctly sequence slugs that uses single dashes as sequence separator" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "journalists"
+      extend FriendlyId
+      friendly_id :name, :use => :slugged, :sequence_separator => '-'
+      def self.name
+        "Journalist"
+      end
+    end
+    transaction do
+      record1 = model_class.create! :name => "Peugeuot 206"
+      assert_equal "peugeuot-206", record1.slug
+      record2 = model_class.create! :name => "Peugeuot 206"
+      assert_equal "peugeuot-206-2", record2.slug
+    end
+  end
+
+  test "should detect when a sequenced slug has changed when name ends in number and using single dash" do
+    model_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "journalists"
+      extend FriendlyId
+      friendly_id :name, :use => :slugged, :sequence_separator => '-'
+    end
+    transaction do
+      record1 = model_class.create! :name => "Peugeuot 206"
+      assert !record1.should_generate_new_friendly_id?
+      record1.save!
+      assert !record1.should_generate_new_friendly_id?
+      record1.name = "Peugeot 307"
+      assert record1.should_generate_new_friendly_id?
+    end
+  end
+end
+
+class DefaultScopeTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :slugged
+    default_scope :order => 'id ASC', :conditions => { :active => true }
+  end
+
+  test "friendly_id should correctly sequence a default_scoped ordered table" do
+    transaction do
+      3.times { assert Journalist.create :name => "a", :active => true }
+    end
+  end
+
+  test "friendly_id should correctly sequence a default_scoped scoped table" do
+    transaction do
+      assert Journalist.create :name => "a", :active => false
+      assert Journalist.create :name => "a", :active => true
+    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
+
+class UnderscoreAsSequenceSeparatorRegressionTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  class Manual < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :slugged, :sequence_separator => "_"
+  end
+
+  test "should not create duplicate slugs" do
+    3.times do
+      begin
+        assert Manual.create! :name => "foo"
+      rescue
+        flunk "Tried to insert duplicate slug"
+      end
+    end
+  end
+
+end
+
+# https://github.com/norman/friendly_id/issues/148
+class FailedValidationAfterUpdateRegressionTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => :slugged
+    validates_presence_of :slug_de
+  end
+
+  test "to_param should return the unchanged value if the slug changes before validation fails" do
+    transaction do
+      journalist = Journalist.create! :name => "Joseph Pulitzer", :slug_de => "value"
+      assert_equal "joseph-pulitzer", journalist.to_param
+      assert journalist.valid?
+      assert journalist.persisted?
+      journalist.name = "Joe Pulitzer"
+      journalist.slug_de = nil
+      assert !journalist.valid?
+      assert_equal "joseph-pulitzer", journalist.to_param
+    end
+  end
+end

data/test/sti_test.rb

@@ -0,0 +1,77 @@
+require "helper"
+
+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
+      def self.table_exists?; false end
+      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 "the configuration's model_class should be the class, not the base_class" do
+    assert_equal model_class, model_class.friendly_id_config.model_class
+  end
+
+  test "friendly_id should accept a block with single table inheritance" do
+    abstract_klass = Class.new(ActiveRecord::Base) do
+      def self.table_exists?; false end
+      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
+
+  test "friendly_id slugs should not clash with eachother" do
+    transaction do
+      journalist  = model_class.base_class.create! :name => 'foo bar'
+      editoralist = model_class.create! :name => 'foo bar'
+
+      assert_equal 'foo-bar', journalist.slug
+      assert_equal 'foo-bar--2', editoralist.slug
+    end
+  end
+
+end
+
+class StiTestWithHistory < StiTest
+  class Journalist < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, :use => [:slugged, :history]
+  end
+
+  class Editorialist < Journalist
+  end
+
+  def model_class
+    Editorialist
+  end
+end