friendly_id4 4.0.0.beta6 → 4.0.0.pre

data/lib/friendly_id/test.rb

@@ -0,0 +1,23 @@
+# Allow declarative test definitions inside modules.
+class Module
+  def test(name, &block)
+    define_method("test_#{name.gsub(/[^a-z0-9]/i, "_")}".to_sym, &block)
+  end
+end
+
+# Use this to create models in your tests, rather than define
+# a bunch of static models. This allows for much more
+# flexbile and granular tests.
+#
+# @name The table name - make sure it is unique.
+# @args The args that will be passed to +has_friendly_id+.
+# @block The block that will be passed to +create_table+.
+def make_model(name, *args, &block)
+  ActiveRecord::Migration.create_table(name, &block)
+  Class.new(ActiveRecord::Base) do
+    self.table_name = name
+    has_friendly_id(*args)
+  end
+end
+
+require "friendly_id/test/generic"

data/lib/friendly_id/test/generic.rb

@@ -0,0 +1,84 @@
+module FriendlyId
+  module Test
+    # Tests for any model that implements FriendlyId. Any test that tests model
+    # features should include this module.
+    module Generic
+
+      def teardown
+        klass.delete_all
+      end
+
+      def instance
+        raise NotImplementedError
+      end
+
+      def klass
+        raise NotImplementedError
+      end
+
+      def other_class
+        raise NotImplementedError
+      end
+
+      test "model classes should have a friendly id config" do
+        assert_not_nil klass.friendly_id_config
+      end
+
+      test "finds should respect conditions" do
+        assert_raise ActiveRecord::RecordNotFound do
+          klass.find(instance.friendly_id, :conditions => "1 = 2")
+        end
+      end
+
+      test "instances should have a friendly id" do
+        assert_not_nil instance.friendly_id
+      end
+
+      test "instances should be findable by their friendly id" do
+        assert_equal instance, klass.find(instance.friendly_id)
+      end
+
+      test "instances should be findable by their numeric id as an integer" do
+        assert_equal instance, klass.find(instance.id.to_i)
+      end
+
+      test "instances should be findable by their numeric id as a string" do
+        assert_equal instance, klass.find(instance.id.to_s)
+      end
+
+      test "instances should be findable by a numeric friendly_id" do
+        instance = klass.create! :name => "206"
+        assert_equal instance, klass.find(instance.friendly_id)
+      end
+
+      test "to_param should return the friendly_id" do
+        assert_equal instance.friendly_id, instance.to_param
+      end
+
+      test "should allow the same friendly_id across models" do
+        other_instance = other_class.create! :name => instance.name
+        assert_equal other_instance.friendly_id, instance.friendly_id
+      end
+
+      test "instances should be findable by themselves" do
+        assert_equal instance, klass.find(instance)
+      end
+
+      test "updating record's other values should not change the friendly_id" do
+        old = instance.friendly_id
+        instance.save
+        assert klass.find(old)
+      end
+
+      test "instances found by a single id should not be read-only" do
+        assert !klass.find(instance.friendly_id).readonly?, "expected instance not to be readonly"
+      end
+
+      test "failing finds with unfriendly_id should raise errors normally" do
+        assert_raise ActiveRecord::RecordNotFound do
+          klass.find(0)
+        end
+      end
+    end
+  end
+end

data/lib/friendly_id/version.rb

@@ -0,0 +1,9 @@
+module FriendlyId
+  module Version
+    MAJOR = 4
+    MINOR = 0
+    TINY  = 0
+    BUILD = 'pre'
+    STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
+  end
+end

data/test/core_test.rb

@@ -1,30 +1,68 @@
-require File.expand_path("../helper.rb", __FILE__)
+require File.expand_path("../test_helper", __FILE__)
 
-Author, Book = 2.times.map do
-  Class.new(ActiveRecord::Base) do
-    extend FriendlyId
-    friendly_id :name
+class ModelTest < Test::Unit::TestCase
+
+  include FriendlyId::Test::Generic
+
+  def instance(name = "user")
+    @instance ||= klass.create!(:name => name)
   end
-end
 
-class CoreTest < MiniTest::Unit::TestCase
+  # @TODO - this kind of setup is repeated in a few places and should probably
+  # be abstracted.
+  def klass
+    @@klass ||= make_model("core", :name) do |t|
+      t.string  :name,   :unique  => true
+      t.boolean :active, :default => true
+    end
+    @@klass
+  end
 
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
+  def other_class
+    @@other_class ||= make_model("core_two", :name) do |t|
+      t.string  :name,   :unique  => true
+      t.boolean :active, :default => true
+    end
+  end
 
-  def model_class
-    Author
+  def setup
+    klass.stubs(:name).returns("Cores")
+    other_class.stubs(:name).returns("CoreTwos")
   end
 
   test "models don't use friendly_id by default" do
-    assert !Class.new(ActiveRecord::Base).respond_to?(:friendly_id)
+    assert !Class.new(ActiveRecord::Base).uses_friendly_id?
+  end
+
+  test "integers should be unfriendly ids" do
+    assert 1.unfriendly_id?
   end
 
-  test "model classes should have a friendly id config" do
-    assert model_class.friendly_id(:name).friendly_id_config
+  test "ActiveRecord::Base instances should be unfriendly_ids" do
+    assert klass.new.unfriendly_id?
   end
 
-  test "instances should have a friendly id" do
-    with_instance_of(model_class) {|record| assert record.friendly_id}
+  test "numeric strings are neither friendly nor unfriendly" do
+    assert_equal nil, "1".friendly_id?
+    assert_equal nil, "1".unfriendly_id?
   end
+
+  test "strings with letters are friendly_ids" do
+    assert "a".friendly_id?
+  end
+
+  test "should raise error when bad config options are set" do
+    assert_raises ArgumentError do
+      klass.has_friendly_id :smeg, :garbage => :in
+    end
+  end
+
+  test "reserves 'new' and 'edit' by default" do
+    FriendlyId::Configuration::DEFAULTS[:reserved_words].each do |word|
+      assert_raises ActiveRecord::RecordInvalid do
+        klass.create! :name => word
+      end
+    end
+  end
+
 end

data/test/scoped_test.rb

@@ -1,57 +1,61 @@
-require File.expand_path("../helper", __FILE__)
-
-class Novelist < ActiveRecord::Base
-  extend FriendlyId
-  friendly_id :name, :use => :slugged
+# encoding: utf-8
+require File.expand_path("../test_helper", __FILE__)
+require "friendly_id/scoped"
+
+Restaurant = make_model("restaurants", :name) do |t|
+  t.string :name
+  t.string :slug
+  t.integer :city_id
 end
 
-class Novel < ActiveRecord::Base
-  extend FriendlyId
-  belongs_to :novelist
-  friendly_id :name, :use => :scoped, :scope => :novelist
+City = make_model("cities", :name) do |t|
+  t.string :name
+  t.string :slug
 end
 
-class ScopedTest < MiniTest::Unit::TestCase
+Restaurant.belongs_to :city
+City.has_many :restaurants
+City.send :include, FriendlyId::Slugged
+Restaurant.send :include, FriendlyId::Scoped
+Restaurant.has_friendly_id :name, :scope => :city
 
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
+class ScopedTest < Test::Unit::TestCase
 
-  def model_class
-    Novel
+  def setup
+    Restaurant.delete_all
+    City.delete_all
   end
 
   test "should detect scope column from belongs_to relation" do
-    assert_equal "novelist_id", Novel.friendly_id_config.scope_column
+    assert_equal "city_id", Restaurant.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
+    klass = Class.new(ActiveRecord::Base)
+    klass.has_friendly_id :empty, :scope => :dummy
+    assert_equal "dummy", klass.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
+    c1 = City.create! :name => "Nuñez"
+    c2 = City.create! :name => "Las Cañitas"
+    r1 = Restaurant.create! :name => "La Guitarrita", :city => c1
+    r2 = Restaurant.create! :name => "La Guitarrita", :city => c2
+    assert_equal r1.friendly_id, r2.friendly_id
   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
+    c1 = City.create! :name => "Nuñez"
+    r1 = Restaurant.create! :name => "La Guitarrita", :city => c1
+    r2 = Restaurant.create! :name => "La Guitarrita", :city => c1
+    assert_not_equal "la-guitarrita", r2.friendly_id
   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
+  test "updating record's other values should not change the friendly_id" do
+    city = City.create! :name => "Nuñez"
+    old = city.friendly_id
+    city.save!
+    assert_equal old, city.friendly_id
   end
+
 end

data/test/slugged_test.rb

@@ -1,83 +1,64 @@
-require File.expand_path("../helper.rb", __FILE__)
+require File.expand_path("../test_helper", __FILE__)
+require "friendly_id/slugged"
 
-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
+class SluggedTest < Test::Unit::TestCase
 
-  include FriendlyId::Test
-  include FriendlyId::Test::Shared::Core
-  include FriendlyId::Test::Shared::Slugged
+  include FriendlyId::Test::Generic
 
-  def model_class
-    Journalist
+  def instance(name = "user")
+    @instance ||= klass.create!(:name => name)
   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"
+  def klass
+    return @@klass if defined?(@@klass)
+    @@klass = make_model("slugged_model", :name) do |t|
+      t.string  :name,   :unique  => true
+      t.string  :slug,   :unique  => true
+      t.boolean :active, :default => true
     end
+    @@klass.send :include, FriendlyId::Slugged
+    @@klass
   end
-end
-
-class SlugSeparatorTest < MiniTest::Unit::TestCase
-
-  include FriendlyId::Test
 
-  class Journalist < ActiveRecord::Base
-    extend FriendlyId
-    friendly_id :name, :use => :slugged, :sequence_separator => ":"
+  def other_class
+    return @@other_class if defined?(@@other_class)
+    @@other_class = make_model("other_slugged_model", :name) do |t|
+      t.string  :name,   :unique  => true
+      t.string  :slug,   :unique  => true
+      t.boolean :active, :default => true
+    end
+    @@other_class.send :include, FriendlyId::Slugged
+    @@other_class
   end
 
-  def model_class
-    Journalist
+  def setup
+    klass.delete_all
+    other_class.delete_all
   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
+  test "configuration should have a sequence_separator" do
+    assert_not_nil klass.friendly_id_config.sequence_separator
   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
+  test "should make a new slug if the friendly_id method value has changed" do
+    instance.name = "Changed Value"
+    instance.save!
+    assert_equal "changed-value", instance.slug
   end
-end
 
-class SluggedRegressionsTest < MiniTest::Unit::TestCase
-  include FriendlyId::Test
-
-  def model_class
-    Journalist
+  test "should increment the slug sequence for duplicate friendly ids" do
+    instance2 = klass.create! :name => instance.name
+    assert_match(/2\z/, instance2.friendly_id)
+    instance3 = klass.create! :name => instance.name
+    assert_match(/3\z/, instance3.friendly_id)
   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
+  test "should not add slug sequence on update after other conflicting slugs were added" do
+    old = instance.friendly_id
+    instance2 = klass.create! :name => instance.name
+    instance.save!
+    instance.reload
+    assert_equal old, instance.to_param
   end
-end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+$VERBOSE = false
+require "rubygems"
+require "bundler/setup"
+require "active_record"
+require "active_support"
+require "friendly_id"
+require "friendly_id/test"
+require "test/unit"
+require "mocha"
+
+ActiveRecord::Migration.verbose = false
+
+# Change the connection args as you see fit to test against different adapters.
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+# 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