galetahub-globalize3 0.2.1

data/test/globalize3/fallbacks_test.rb

@@ -0,0 +1,146 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class TranslatedTest < Test::Unit::TestCase
+  def setup
+    @previous_backend = I18n.backend
+    I18n.pretend_fallbacks
+    I18n.backend = BackendWithFallbacks.new
+
+    I18n.locale = :'en-US'
+    I18n.fallbacks = ::I18n::Locale::Fallbacks.new
+  end
+
+  def teardown
+    I18n.fallbacks.clear
+    I18n.hide_fallbacks
+    I18n.backend = @previous_backend
+  end
+
+  test "keeping one field in new locale when other field is changed" do
+    I18n.fallbacks.map('de-DE' => [ 'en-US' ])
+    post = Post.create :title => 'foo'
+
+    I18n.locale = 'de-DE'
+    post.content = 'bar'
+
+    assert_equal 'foo', post.title
+  end
+
+  test "modifying non-required field in a new locale" do
+    I18n.fallbacks.map 'de-DE' => [ 'en-US' ]
+    post = Post.create :title => 'foo'
+    I18n.locale = 'de-DE'
+    post.content = 'bar'
+    assert post.save
+  end
+
+  test "resolves a simple fallback" do
+    I18n.locale = 'de-DE'
+    post = Post.create :title => 'foo'
+
+    I18n.locale = 'de'
+    post.title = 'baz'
+    post.content = 'bar'
+    post.save!
+
+    I18n.locale = 'de-DE'
+    assert_equal 'foo', post.title
+    assert_equal 'bar', post.content
+  end
+
+  test "resolves a simple fallback without reloading" do
+    I18n.locale = 'de-DE'
+    post = Post.new :title => 'foo'
+
+    I18n.locale = 'de'
+    post.title = 'baz'
+    post.content = 'bar'
+
+    I18n.locale = 'de-DE'
+    assert_equal 'foo', post.title
+    assert_equal 'bar', post.content
+  end
+
+  test "resolves a complex fallback without reloading" do
+    I18n.fallbacks.map 'de' => %w(en he)
+    I18n.locale = 'de'
+    post = Post.new
+    I18n.locale = 'en'
+    post.title = 'foo'
+    I18n.locale = 'he'
+    post.title = 'baz'
+    post.content = 'bar'
+    I18n.locale = 'de'
+    assert_equal 'foo', post.title
+    assert_equal 'bar', post.content
+  end
+
+  test 'fallbacks with lots of locale switching' do
+    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+    post = Post.create :title => 'foo'
+
+    I18n.locale = :'de-DE'
+    assert_equal 'foo', post.title
+
+    I18n.locale = :'en-US'
+    post.update_attributes(:title => 'bar')
+
+    I18n.locale = :'de-DE'
+    assert_equal 'bar', post.title
+  end
+
+  test 'fallbacks with lots of locale switching 2' do
+    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+    child = Child.create :content => 'foo'
+
+    I18n.locale = :'de-DE'
+    assert_equal 'foo', child.content
+
+    I18n.locale = :'en-US'
+    child.update_attributes(:content => 'bar')
+
+    I18n.locale = :'de-DE'
+    assert_equal 'bar', child.content
+  end
+
+  test 'fallbacks with nil translations' do
+    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+    post = Post.create :title => 'foo'
+
+    I18n.locale = :'de-DE'
+    assert_equal 'foo', post.title
+
+    post.update_attribute :title, nil
+    assert_equal 'foo', post.title
+  end
+
+  test 'fallbacks with empty translations' do
+    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+    task = Task.create :name => 'foo'
+
+    I18n.locale = :'de-DE'
+    assert_equal 'foo', task.name
+
+    task.update_attribute :name, ''
+    assert_equal 'foo', task.name
+  end
+
+  test 'fallbacks with empty translations 2' do
+    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+    task = Task.create :name => 'foo'
+    post = Post.create :title => 'foo'
+
+    I18n.locale = :'de-DE'
+    assert_equal 'foo', task.name
+    assert_equal 'foo', post.title
+
+    task.update_attribute :name, ''
+    assert_equal 'foo', task.name
+
+    post.update_attribute :title, ''
+    assert_equal '', post.title
+  end
+end
+# TODO should validate_presence_of take fallbacks into account? maybe we need
+#   an extra validation call, or more options for validate_presence_of.
+

data/test/globalize3/locale_test.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class LocaleTest < Test::Unit::TestCase
+  test "Globalize has locale accessors" do
+    assert Globalize.respond_to?(:locale)
+    assert Globalize.respond_to?(:locale=)
+  end
+
+  test "Globalize.locale reader can be called before a locale was set" do
+    Globalize.locale = nil
+    assert_nothing_raised { Globalize.locale }
+  end
+
+  test 'Globalize locale setting' do
+    assert_equal :en, I18n.locale
+    assert_equal :en, Globalize.locale
+
+    I18n.locale = :de
+    assert_equal :de, I18n.locale
+    assert_equal :de, Globalize.locale
+
+    Globalize.locale = :es
+    assert_equal :de, I18n.locale
+    assert_equal :es, Globalize.locale
+
+    I18n.locale = :fr
+    assert_equal :fr, I18n.locale
+    assert_equal :es, Globalize.locale
+  end
+
+  test "Globalize locale setting with strings" do
+    I18n.locale = 'de'
+    Globalize.locale = 'de'
+    assert_equal I18n.locale, Globalize.locale
+
+    I18n.locale = 'de'
+    Globalize.locale = :de
+    assert_equal I18n.locale, Globalize.locale
+
+    I18n.locale =  :de
+    Globalize.locale = 'de'
+    assert_equal I18n.locale, Globalize.locale
+  end
+
+  test 'with_locale temporarily sets the given locale and yields the block' do
+    assert_equal :en, Globalize.locale
+    Globalize.with_locale :de do |locale|
+      assert_equal :de, Globalize.locale
+      assert_equal :de, locale
+    end
+    assert_equal :en, Globalize.locale
+  end
+
+  test 'with_locales calls block once with each locale given temporarily set' do
+    locales = Globalize.with_locales :en, [:de, :fr] do |locale|
+      assert_equal locale, Globalize.locale
+      locale
+    end
+    assert_equal [:en, :de, :fr], locales
+  end
+
+  test "attribute saving goes by content locale and not global locale" do
+    Globalize.locale = :de
+    assert_equal :en, I18n.locale
+    Post.create :title => 'foo'
+    assert_equal :de, Post.first.translations.first.locale
+  end
+
+  test "attribute loading goes by content locale and not global locale" do
+    post = Post.create(:title => 'title')
+    assert_translated Post.first, :en, :title, 'title'
+
+    Globalize.locale = :de
+    post.update_attributes(:title => 'Titel')
+
+    assert_translated Post.first, :en, :title, 'title'
+    assert_translated Post.first, :de, :title, 'Titel'
+  end
+end

data/test/globalize3/migration_test.rb

@@ -0,0 +1,156 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class MigrationTest < Test::Unit::TestCase
+  include Globalize::ActiveRecord::Exceptions
+
+  def setup
+    super
+    reset_schema(Migrated, MigratedWithUltraLongModelName)
+    assert !Migrated::Translation.table_exists?
+    assert !Migrated::Translation.index_exists_on?(:migrated_id)
+  end
+
+  def teardown
+    reset_schema(Migrated, MigratedWithUltraLongModelName)
+  end
+
+  test 'create_translation_table!(:name => :text) adds the translations table' do
+    Migrated.create_translation_table!(:name => :text)
+    assert_migration_table(:name => :text)
+  end
+
+  test 'create_translation_table! adds the translations table using the column type from the translated model' do
+    Migrated.create_translation_table!
+    assert_migration_table(:name => :string)
+  end
+
+  test 'create_translation_table! can not be called on non-translated models' do
+    assert_raise NoMethodError do
+      Blog.create_translation_table!(:name => :string)
+    end
+  end
+
+  test 'passing a non-translated field name raises BadFieldName' do
+    assert_raise BadFieldName do
+      Migrated.create_translation_table!(:content => :text)
+    end
+  end
+
+  test 'passing a translated field with a wrong type raises BadFieldType' do
+    assert_raise BadFieldType do
+      Migrated.create_translation_table!(:name => :integer)
+    end
+  end
+
+  test 'drop_translation_table! drops the translations table' do
+    Migrated.create_translation_table!(:name => :string)
+    assert Migrated::Translation.table_exists?
+    assert Migrated::Translation.index_exists_on?(:migrated_id)
+
+    Migrated.drop_translation_table!
+    assert !Migrated::Translation.table_exists?
+    assert !Migrated::Translation.index_exists_on?(:migrated_id)
+  end
+
+  test 'drop_translation_table! can not be called on non-translated models' do
+    assert_raise NoMethodError do
+      Blog.drop_translation_table!
+    end
+  end
+
+  test "translation_index_name returns a readable index name if it's not longer than 50 characters" do
+    assert_equal 'index_migrated_translations_on_migrated_id', Migrated.send(:translation_index_name)
+  end
+
+  test "translation_index_name returns a hashed index name if it's longer than 50 characters" do
+    assert_match /^index_[a-z0-9]{40}$/, MigratedWithUltraLongModelName.send(:translation_index_name)
+  end
+
+  test 'create_translation_table! can deal with ultra long table names' do
+    model = MigratedWithUltraLongModelName
+    model.create_translation_table!(:name => :string)
+
+    assert model::Translation.table_exists?
+    assert model::Translation.index_exists?(model.send(:translation_index_name))
+  end
+
+  test 'drop_translation_table! can deal with ultra long table names' do
+    model = MigratedWithUltraLongModelName
+    model.create_translation_table!(:name => :string)
+    model.drop_translation_table!
+
+    assert !model::Translation.table_exists?
+    assert !model::Translation.index_exists?(:ultra_long_model_name_without_proper_id)
+  end
+
+  # This test is relatively exhaustive in that it tests the full stack of
+  # create_translation_table! and its ability to use migrate_data to migrate
+  # non translated data into the default Globalize locale.
+  # We are then testing the ability of drop_translation_table! to migrate the
+  # translated data from the default Globalize locale back as untranslated data.
+  test 'create_translation_table! with option migrate_data set to true DOES migrate existing data AND rolls back' do
+    # Ensure we have a "Fresh" version. Can't use reset_schema because it's not a translated model, yet.
+    model = Untranslated
+    model.drop_translation_table! if model.respond_to?(:drop_translation_table!)
+    model.reset_column_information rescue nil
+
+    # First create an untranslated record
+    untranslated = model.create! :name => 'Untranslated'
+
+    # Now add translation support and migrate (also tests .untranslated_attributes)
+    model.instance_eval %{ translates :name }
+    model.create_translation_table!({:name => :string}, {:migrate_data => true})
+    assert model::Translation.table_exists?
+
+    # Reload the untranslated record
+    untranslated.reload
+
+    # Was it migrated?
+    assert_translated untranslated, :en, :name, 'Untranslated'
+
+    # Cool, now we need to get rid of the non-translated value for the next test
+    model.update_all({:name => 'No longer translated'}, :id => untranslated.id)
+    untranslated.reload
+
+    # Make sure we didn't harm the translation and that it's been set. (also tests .untranslated_attributes)
+    assert_equal 'No longer translated', untranslated.untranslated_attributes['name']
+    assert_translated untranslated, :en, :name, 'Untranslated'
+
+    # Now we need to rollback then undo
+    model.drop_translation_table! :migrate_data => true
+    model.reset_column_information rescue nil
+    assert !model::Translation.table_exists?
+    untranslated.reload
+
+    # Was it restored? (also tests .untranslated_attributes)
+    assert_equal 'Untranslated', untranslated.untranslated_attributes['name']
+  end
+
+protected
+
+  def reset_schema(*models)
+    models.each do |model|
+      model.reset_column_information rescue nil
+      model::Translation.reset_column_information rescue nil
+      model.drop_translation_table! if model::Translation.table_exists?
+    end
+  end
+
+  def column_type(name)
+    Migrated::Translation.columns.detect { |c| c.name == name.to_s }.try(:type)
+  end
+
+  def assert_migration_table(fields)
+    assert Migrated::Translation.table_exists?
+    assert Migrated::Translation.index_exists_on?(:migrated_id)
+
+    assert_equal :string,   column_type(:locale)
+    assert_equal :integer,  column_type(:migrated_id)
+    assert_equal :datetime, column_type(:created_at)
+    assert_equal :datetime, column_type(:updated_at)
+
+    fields.each do |name, type|
+      assert_equal type, column_type(name)
+    end
+  end
+end

data/test/globalize3/set_translations_test.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class AttributesTest < Test::Unit::TestCase
+  test "set_translations sets multiple translations at once" do
+    post = Post.create(:title => 'title', :content => 'content', :locale => :en)
+    post.update_attributes(:title => 'Titel', :content => 'Inhalt', :locale => :de)
+
+    post.set_translations(
+      :en => { :title => 'updated title', :content => 'updated content' },
+      :de => { :title => 'geänderter Titel', :content => 'geänderter Inhalt' }
+    )
+    post.reload
+
+    assert_translated post, :en, [:title, :content], ['updated title', 'updated content']
+    assert_translated post, :de, [:title, :content], ['geänderter Titel', 'geänderter Inhalt']
+  end
+
+  test "set_translations does not touch existing translations for other locales" do
+    post = Post.create(:title => 'title', :content => 'content', :locale => :en)
+    post.update_attributes(:title => 'Titel', :content => 'Inhalt', :locale => :de)
+
+    post.set_translations(:en => { :title => 'updated title', :content => 'updated content' })
+    post.reload
+
+    assert_translated post, :en, [:title, :content], ['updated title', 'updated content']
+    assert_translated post, :de, [:title, :content], ['Titel', 'Inhalt']
+  end
+
+  test "set_translations does not touch existing translations for other attributes" do
+    post = Post.create(:title => 'title', :content => 'content', :locale => :en)
+    post.update_attributes(:title => 'Titel', :content => 'Inhalt', :locale => :de)
+
+    post.set_translations(
+      :en => { :title => "updated title" },
+      :de => { :content => "geänderter Inhalt" }
+    )
+    post.reload
+
+    assert_translated post, :en, [:title, :content], ['updated title', 'content']
+    assert_translated post, :de, [:title, :content], ['Titel', 'geänderter Inhalt']
+  end
+
+  test "set_translations raises an UnknownAttributeError on unknown attributes" do
+    post = Post.create(:title => 'title', :content => 'content', :locale => :en)
+    post.update_attributes(:title => 'Titel', :content => 'Inhalt', :locale => :de)
+
+    options = { :de => { :does_not_exist => 'should raise' } }
+    assert_raises(ActiveRecord::UnknownAttributeError, 'unknown attribute: does_not_exist') do
+      post.set_translations options
+    end
+  end
+end

data/test/globalize3/translation_class_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class TranslationClassTest < Test::Unit::TestCase
+  test 'translation_class returns the Translation class' do
+    assert_equal Post::Translation, Post.translation_class
+  end
+
+  test 'defines a Translation class nested in the model class' do
+    assert Post.const_defined?(:Translation)
+  end
+
+  test 'defines a belongs_to association' do
+    assert_belongs_to Post::Translation, :post
+  end
+
+  test 'defines a reader for :locale that returns a symbol' do
+    post = Post::Translation.new
+    post.send(:write_attribute, 'locale', 'de')
+    assert_equal :de, post.locale
+  end
+
+  test 'defines a write for :locale that writes a string' do
+    post = Post::Translation.new
+    post.locale = :de
+    assert_equal 'de', post.read_attribute('locale')
+  end
+  
+  test "can create a translation class for a namespaced model" do
+    assert_nothing_raised do
+      module Foo
+        module Bar
+          class Baz < ActiveRecord::Base
+            translates :bumm
+          end
+        end
+      end
+    end
+  end
+
+  test "can create a translation class for a model with an uppercase table name" do
+    assert_nothing_raised do
+      UppercaseTableName.create
+    end
+  end
+  
+  test "does not override existing translation class" do
+    assert PostTranslation.new.respond_to?(:existing_method)
+  end
+
+  test "required_attributes returns required attributes (i.e. validates_presence_of)" do
+    assert_equal [:name, :email], User.required_attributes
+  end
+
+  test "required_translated_attributes do not include non-translated attributes" do
+    assert_equal [:name], User.required_translated_attributes
+  end
+end
+
+