geothird_friendly_id 4.0.9.1

data/test/configuration_test.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+class ConfigurationTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+
+  def setup
+    @model_class = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+    end
+  end
+
+  test "should set model class on initialization" do
+    config = FriendlyId::Configuration.new @model_class
+    assert_equal @model_class, config.model_class
+  end
+
+  test "should set options on initialization if present" do
+    config = FriendlyId::Configuration.new @model_class, :base => "hello"
+    assert_equal "hello", config.base
+  end
+
+  test "should raise error if passed unrecognized option" do
+    assert_raises NoMethodError do
+      FriendlyId::Configuration.new @model_class, :foo => "bar"
+    end
+  end
+
+  test "#use should accept a name that resolves to a module" do
+    refute @model_class < FriendlyId::Slugged
+    @model_class.class_eval do
+      extend FriendlyId
+      friendly_id :hello, :use => :slugged
+    end
+    assert @model_class < FriendlyId::Slugged
+  end
+
+  test "#use should accept a module" do
+    my_module = Module.new
+    refute @model_class < my_module
+    @model_class.class_eval do
+      extend FriendlyId
+      friendly_id :hello, :use => my_module
+    end
+    assert @model_class < my_module
+  end
+
+end

data/test/core_test.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+class Book < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name
+end
+
+class Author < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :name
+  has_many :books
+end
+
+class CoreTest < MiniTest::Unit::TestCase
+
+  include FriendlyId::Test
+  include FriendlyId::Test::Shared::Core
+
+  def model_class
+    Author
+  end
+
+  test "models don't use friendly_id by default" do
+    assert !Class.new(ActiveRecord::Base) {
+      self.abstract_class = true
+    }.respond_to?(:friendly_id)
+  end
+
+  test "model classes should have a friendly id config" do
+    assert model_class.friendly_id(:name).friendly_id_config
+  end
+
+  test "instances should have a friendly id" do
+    with_instance_of(model_class) {|record| assert record.friendly_id}
+  end
+
+  test "instances can be marshaled when a relationship is used" do
+    transaction do
+      author = Author.create :name => 'Philip'
+      author.books.create :name => 'my book'
+      begin
+        assert Marshal.load(Marshal.dump(author))
+      rescue TypeError => e
+        flunk(e.to_s)
+      end
+    end
+  end
+end

data/test/databases.yml

@@ -0,0 +1,19 @@
+mysql:
+  adapter: mysql2
+  database: friendly_id_test
+  username: root
+  hostname: localhost
+  encoding: utf8
+
+postgres:
+  adapter: postgresql
+  host: localhost
+  port: 5432
+  username: postgres
+  database: friendly_id_test
+  encoding: utf8
+
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"
+  encoding: utf8

data/test/generator_test.rb

@@ -0,0 +1,20 @@
+require "helper"
+require "rails/generators"
+require "generators/friendly_id_generator"
+
+class FriendlyIdGeneratorTest < Rails::Generators::TestCase
+
+  tests FriendlyIdGenerator
+  destination File.expand_path("../../tmp", __FILE__)
+
+  setup :prepare_destination
+
+  test "should generate a migration" do
+    begin
+      run_generator
+      assert_migration "db/migrate/create_friendly_id_slugs"
+    ensure
+      FileUtils.rm_rf self.destination_root
+    end
+  end
+end

data/test/globalize_test.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require "helper"
+
+class TranslatedArticle < ActiveRecord::Base
+  translates :slug, :title
+  extend FriendlyId
+  friendly_id :title, :use => :globalize
+end
+
+class GlobalizeTest < MiniTest::Unit::TestCase
+  include FriendlyId::Test
+
+  def setup
+    I18n.locale = :en
+  end
+
+  test "should find slug in current locale if locale is set, otherwise in default locale" do
+    transaction do
+      I18n.default_locale = :en
+      article_en = I18n.with_locale(:en) { TranslatedArticle.create(:title => 'a title') }
+      article_de = I18n.with_locale(:de) { TranslatedArticle.create(:title => 'titel') }
+
+      I18n.with_locale(:de) {
+        assert_equal TranslatedArticle.find("titel"), article_de
+        assert_equal TranslatedArticle.find("a-title"), article_en
+      }
+    end
+  end
+
+  test "should set friendly id for locale" do
+    transaction do
+      article = TranslatedArticle.create!(:title => "War and Peace")
+      article.set_friendly_id("Guerra y paz", :es)
+      article.save!
+      article = TranslatedArticle.find('war-and-peace')
+      I18n.with_locale(:es) { assert_equal "guerra-y-paz", article.friendly_id }
+      I18n.with_locale(:en) { assert_equal "war-and-peace", article.friendly_id }
+    end
+  end
+
+  # https://github.com/svenfuchs/globalize3/blob/master/test/globalize3/dynamic_finders_test.rb#L101
+  # see: https://github.com/svenfuchs/globalize3/issues/100
+  test "record returned by friendly_id should have all translations" do
+    transaction do
+      I18n.with_locale(:en) do
+        article = TranslatedArticle.create(:title => 'a title')
+        Globalize.with_locale(:ja) { article.update_attributes(:title => 'タイトル') }
+        article_by_friendly_id = TranslatedArticle.find("a-title")
+        article.translations.each do |translation|
+          assert_includes article_by_friendly_id.translations, translation
+        end
+      end
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,87 @@
+require "rubygems"
+require "bundler/setup"
+require "minitest/unit"
+require "mocha"
+require "active_record"
+require 'active_support/core_ext/time/conversions'
+
+
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "test/"
+    add_filter "friendly_id/migration"
+  end
+end
+
+require "friendly_id"
+
+# If you want to see the ActiveRecord log, invoke the tests using `rake test LOG=true`
+if ENV["LOG"]
+  require "logger"
+  ActiveRecord::Base.logger = Logger.new($stdout)
+end
+
+module FriendlyId
+  module Test
+
+    def self.included(base)
+      MiniTest::Unit.autorun
+    end
+
+    def transaction
+      ActiveRecord::Base.transaction { yield ; raise ActiveRecord::Rollback }
+    end
+
+    def with_instance_of(*args)
+      model_class = args.shift
+      args[0] ||= {:name => "a b c"}
+      transaction { yield model_class.create!(*args) }
+    end
+
+    module Database
+      extend self
+
+      def connect
+        version = ActiveRecord::VERSION::STRING
+        driver  = FriendlyId::Test::Database.driver
+        engine  = RUBY_ENGINE rescue "ruby"
+
+        ActiveRecord::Base.establish_connection config[driver]
+        message = "Using #{engine} #{RUBY_VERSION} AR #{version} with #{driver}"
+
+        puts "-" * 72
+        if in_memory?
+          ActiveRecord::Migration.verbose = false
+          Schema.up
+          puts "#{message} (in-memory)"
+        else
+          puts message
+        end
+      end
+
+      def config
+        @config ||= YAML::load(File.open(File.expand_path("../databases.yml", __FILE__)))
+      end
+
+      def driver
+        (ENV["DB"] or "sqlite3").downcase
+      end
+
+      def in_memory?
+        config[driver]["database"] == ":memory:"
+      end
+    end
+  end
+end
+
+class Module
+  def test(name, &block)
+    define_method("test_#{name.gsub(/[^a-z0-9']/i, "_")}".to_sym, &block)
+  end
+end
+
+require "schema"
+require "shared"
+FriendlyId::Test::Database.connect
+at_exit {ActiveRecord::Base.connection.disconnect!}

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