galetahub-globalize3 0.2.1

data/test/data/schema.rb

@@ -0,0 +1,108 @@
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :translations, :force => true do |t|
+    t.string   :blah
+  end
+
+  create_table :blogs, :force => true do |t|
+    t.string   :description
+  end
+
+  create_table :posts, :force => true do |t|
+    t.references :blog
+    t.boolean    :published
+  end
+
+  create_table :post_translations, :force => true do |t|
+    t.string     :locale
+    t.references :post
+    t.string     :title
+    t.text       :content
+    t.boolean    :published
+    t.datetime   :published_at
+  end
+
+  create_table :parents, :force => true do |t|
+  end
+
+  create_table :parent_translations, :force => true do |t|
+    t.string     :locale
+    t.references :parent
+    t.text       :content
+    t.string     :type
+  end
+
+  create_table :comments, :force => true do |t|
+    t.references :post
+  end
+
+  create_table :comment_translations, :force => true do |t|
+    t.string     :locale
+    t.references :comment
+    t.string     :title
+    t.text       :content
+  end
+
+  create_table :migrateds, :force => true do |t|
+    t.string :name
+    t.string :untranslated
+  end
+
+  create_table :untranslateds, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :validatees, :force => true do |t|
+  end
+
+  create_table :validatee_translations, :force => true do |t|
+    t.references :validatee
+    t.string     :locale
+    t.string     :string
+  end
+
+  create_table :users, :force => true do |t|
+    t.string   :email
+    t.datetime :created_at
+  end
+
+  create_table :user_translations, :force => true do |t|
+    t.references :user
+    t.string     :locale
+    t.string     :name
+  end
+
+  create_table :tasks, :force => true do |t|
+    t.string   :name
+    t.datetime :created_at
+  end
+
+  create_table :task_translations, :force => true do |t|
+    t.references :task
+    t.string     :locale
+    t.string     :name
+  end
+
+  create_table "versions", :force => true do |t|
+    t.string   "item_type",  :null => false
+    t.integer  "item_id",    :null => false
+    t.string   "event",      :null => false
+    t.string   "whodunnit"
+    t.text     "object"
+    t.string   "locale"
+    t.datetime "created_at"
+  end
+
+  add_index "versions", ["item_type", "item_id"], :name => "index_versions_on_item_type_and_item_id"
+
+  create_table 'UPPERCASE_TABLE_NAME', :force => true do |t|
+    t.string :name
+  end
+
+  create_table :UPPERCASE_TABLE_NAME_translations, :force => true do |t|
+    t.integer 'UPPERCASE_TABLE_NAME_id'
+    t.string     :locale
+    t.string     :name
+  end
+end

data/test/globalize3/attributes_test.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class AttributesTest < Test::Unit::TestCase
+  test 'defines accessors for the translated attributes' do
+    post = Post.new
+    assert post.respond_to?(:title)
+    assert post.respond_to?(:title=)
+  end
+
+  test "attribute_names returns translated and regular attribute names" do
+    assert_equal %w(blog_id content title), Post.new.attribute_names.sort & %w(blog_id content title)
+  end
+
+  test "attributes returns translated and regular attributes" do
+    post = Post.create(:title => 'foo')
+    attributes = post.attributes.slice('id', 'blog_id', 'title', 'content')
+    assert_equal({ 'id' => post.id, 'blog_id' => nil, 'title' => 'foo', 'content' => nil }, attributes)
+  end
+  
+  test "write_attribute for non-translated attributes should return the value" do
+    user = User.create(:name => 'Max Mustermann', :email => 'max@mustermann.de')
+    new_email = 'm.muster@mann.de'
+    assert_equal new_email, user.write_attribute('email', new_email)
+  end
+
+  test 'translated_attribute_names returns translated attribute names' do
+    assert_equal [:title, :content], Post.translated_attribute_names & [:title, :content]
+  end
+
+  test "a translated attribute writer returns its argument" do
+    assert_equal 'foo', Post.new.title = 'foo'
+  end
+
+  test "a translated attribute reader returns the correct translation for a saved record after locale switching" do
+    post = Post.create(:title => 'title')
+    post.update_attributes(:title => 'Titel', :locale => :de)
+    post.reload
+
+    assert_translated post, :en, :title, 'title'
+    assert_translated post, :de, :title, 'Titel'
+  end
+
+  test "a translated attribute reader returns the correct translation for an unsaved record after locale switching" do
+    post = Post.create(:title => 'title')
+    with_locale(:de) { post.title = 'Titel' }
+
+    assert_translated post, :en, :title, 'title'
+    assert_translated post, :de, :title, 'Titel'
+  end
+
+  test "a translated attribute reader returns the correct translation for both saved/unsaved records while switching locales" do
+    post = Post.new(:title => 'title')
+    with_locale(:de) { post.title = 'Titel' }
+    with_locale(:he) { post.title = 'שם' }
+
+    assert_translated post, :de, :title, 'Titel'
+    assert_translated post, :he, :title, 'שם'
+    assert_translated post, :en, :title, 'title'
+    assert_translated post, :he, :title, 'שם'
+    assert_translated post, :de, :title, 'Titel'
+
+    post.save
+    post.reload
+
+    assert_translated post, :de, :title, 'Titel'
+    assert_translated post, :he, :title, 'שם'
+    assert_translated post, :en, :title, 'title'
+    assert_translated post, :he, :title, 'שם'
+    assert_translated post, :de, :title, 'Titel'
+  end
+
+  test "a translated attribute reader returns nil if no translations are found on an unsaved record" do
+    post = Post.new(:title => 'foo')
+    assert_equal 'foo', post.title
+    assert_nil post.content
+  end
+
+  test "a translated attribute reader returns nil if no translations are found on a saved record" do
+    post = Post.create(:title => 'foo')
+    post.reload
+    assert_equal 'foo', post.title
+    assert_nil post.content
+  end
+
+  test "before_type_cast reader works for translated attributes" do
+    post = Post.create(:title => 'title')
+    post.update_attributes(:title => "Titel", :locale => :de)
+
+    with_locale(:en) { assert_equal 'title', post.title_before_type_cast }
+    with_locale(:de) { assert_equal 'Titel', post.title_before_type_cast }
+  end
+
+  test "saves all translations on an sti model after locale switching" do
+    child = Child.new(:content => 'foo')
+    with_locale(:de) { child.content = 'bar' }
+    with_locale(:he) { child.content = 'baz' }
+    child.save
+    child.reload
+
+    assert_translated child, :en, :content, 'foo'
+    assert_translated child, :de, :content, 'bar'
+    assert_translated child, :he, :content, 'baz'
+  end
+
+  test 'attribute reader without arguments will use the current locale on Globalize or I18n' do
+    with_locale(:de) do
+      Post.create!(:title => 'Titel', :content => 'Inhalt')
+    end
+    I18n.locale = :de
+    assert_equal 'Titel', Post.first.title
+  
+    I18n.locale = :en
+    Globalize.locale = :de
+    assert_equal 'Titel', Post.first.title
+  end
+
+  test 'attribute reader when passed a locale will use the given locale' do
+    post = with_locale(:de) do
+      Post.create!(:title => 'Titel', :content => 'Inhalt')
+    end
+    assert_equal 'Titel', post.title(:de)
+  end
+
+  test 'modifying a translated attribute does not change the untranslated value' do
+    post = Post.create(:title => 'title')
+    before = post.untranslated_attributes['title']
+    post.title = 'changed title'
+    assert_equal post.untranslated_attributes['title'], before
+  end
+
+end

data/test/globalize3/clone_test.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class CloneTest < Test::Unit::TestCase
+
+  test 'stores translations from clonned new record' do
+    check_stored_translations(standard_post.clone)
+  end
+
+  test 'stores translations from clonned created record' do
+    clonned = saved_post.clone
+    check_stored_translations(clonned)
+  end
+
+  test 'stores translations from clonned found record' do
+    check_stored_translations( Post.find(saved_post).clone )
+  end
+
+  test 'stores translations from clonned reloaded after creation record' do
+    check_stored_translations(saved_post.reload.clone)
+  end
+
+
+  private
+
+  
+    def standard_post
+      p = Post.new({:title => 'title', :content => 'content'})
+      with_locale(:he) { p.title= 'שם' }
+      return p
+    end
+
+    def saved_post
+      standard_post.tap{|p| p.save!}
+    end
+
+    def translations_modifications(clonned)
+      clonned.content = 'another content'
+      with_locale(:de) { clonned.title = 'Titel' }
+    end
+
+    def translations_assertions(clonned)
+      assert_translated clonned, :en, :title,   'title'               # original
+      assert_translated clonned, :en, :content, 'another content'     # changed
+      assert_translated clonned, :de, :title,   'Titel'               # new
+      assert_translated clonned, :he, :title,    'שם'                 # untouched language
+    end
+
+    def check_stored_translations(clonned)
+      translations_modifications(clonned)
+      translations_assertions(clonned)
+      clonned.save!
+      clonned.reload
+      translations_assertions(clonned)
+    end
+  
+end

data/test/globalize3/dirty_tracking_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DirtyTrackingTest < Test::Unit::TestCase
+  test "dirty tracking works" do
+    post = Post.create(:title => 'title', :content => 'content')
+    assert_equal [], post.changed
+
+    post.title = 'changed title'
+    assert_equal ['title'], post.changed
+
+    post.content = 'changed content'
+    assert_included 'title', post.changed
+    assert_included 'content', post.changed
+  end
+
+  test 'dirty tracking works per a locale' do
+    post = Post.create(:title => 'title', :content => 'content')
+    assert_equal [], post.changed
+
+    post.title = 'changed title'
+    assert_equal({ 'title' => ['title', 'changed title'] }, post.changes)
+    post.save
+
+    I18n.locale = :de
+    assert_equal nil, post.title
+
+    post.title = 'Titel'
+    assert_equal({ 'title' => [nil, 'Titel'] }, post.changes)
+  end
+
+  # ummm ... is this actually desired behaviour? probably depends on how we use it
+  test 'dirty tracking works after locale switching' do
+    post = Post.create(:title => 'title', :content => 'content')
+    assert_equal [], post.changed
+
+    post.title = 'changed title'
+    I18n.locale = :de
+    assert_equal ['title'], post.changed
+  end
+
+  test 'dirty tracking works on sti model' do
+    child = Child.create(:content => 'foo')
+    assert_equal [], child.changed
+
+    child.content = 'bar'
+    assert_equal ['content'], child.changed
+
+    child.content = 'baz'
+    assert_included 'content', child.changed
+  end
+
+  test 'dirty tracking works on sti model after locale switching' do
+    child = Child.create(:content => 'foo')
+    assert_equal [], child.changed
+
+    child.content = 'bar'
+    I18n.locale = :de
+
+    assert_equal ['content'], child.changed
+  end
+end

data/test/globalize3/dynamic_finders_test.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+class DynamicFindersTest < Test::Unit::TestCase
+
+  test "Does not break normal finders" do
+    user = User.create!(:name => "name", :email => "email@example.org")
+
+    assert_equal user,   User.find_by_email(user.email)
+    assert_equal [user], User.find_all_by_email([user.email])
+
+    assert_equal user, User.find_by_id_and_created_at(user.id, user.created_at)
+    assert_equal user, User.find_by_id_and_email(user.id, user.email)
+
+    assert_equal [user], User.find_all_by_id_and_created_at(user.id, user.created_at)
+    assert_equal [user], User.find_all_by_id_and_email(user.id, user.email)
+  end
+
+  test "simple dynamic finders do work" do
+    foo = Post.create!(:title => 'foo')
+    bar = Post.create!(:title => 'bar')
+
+    assert_equal foo, Post.find_by_title('foo')
+    assert_equal bar, Post.find_by_title('bar')
+    assert_nil        Post.find_by_title("non existing")
+
+    assert_equal [foo], Post.find_all_by_title('foo')
+    assert_equal [],    Post.find_all_by_title('non existing')
+  end
+
+  # https://github.com/svenfuchs/globalize3/issues#issue/5
+  test "simple dynamic finders retruns results from current locale and fallbacks" do
+    en, de, he = 'title', 'titel', 'שם'
+    post = Post.create!(:title => en)
+    post.update_attributes!(:title => de, :locale => :de)
+    post.update_attributes!(:title => he, :locale => :he)
+
+    with_fallbacks do
+      I18n.fallbacks = {:de => [:de, :en], :he => [:he, :en], :en => [:en]}
+
+      with_locale(:en) do
+        assert Post.find_by_title(en)
+        assert_nil Post.find_by_title(de)
+      end
+
+      with_locale(:de) do
+        assert Post.find_by_title(en)
+        assert Post.find_by_title(de)
+        assert_nil Post.find_by_title(he)
+      end
+
+      with_locale(:he) do
+        assert Post.find_by_title(en)
+        assert Post.find_by_title(he)
+        assert_nil Post.find_by_title(de)
+      end
+
+      I18n.fallbacks.clear
+    end
+  end
+
+  test "simple dynamic finders do work on sti models" do
+    Child.create(:content => 'foo')
+    Child.create(:content => 'bar')
+
+    assert_equal 'foo', Child.find_by_content('foo').content
+    assert_equal 'foo', Child.find_all_by_content('foo').first.content
+  end
+
+  test "records returned by dynamic finders have writable attributes" do
+    Post.create(:title => 'original')
+    post = Post.find_by_title('original')
+    post.title = 'modified'
+    assert_nothing_raised(ActiveRecord::ReadOnlyRecord) do
+      post.save
+    end
+  end
+
+  test "responds to possible dynamic finders" do
+    assert Post.respond_to?(:find_by_title)
+    assert Post.respond_to?(:find_all_by_title)
+    assert Post.respond_to?(:find_by_title_and_content)
+    assert Post.respond_to?(:find_all_by_title_and_content)
+  end
+
+  test "does not responds to impossible dynamic finders" do
+    assert ! Post.respond_to?(:find_by_foo)
+    assert ! Post.respond_to?(:find_all_by_foo)
+    assert ! Post.respond_to?(:find_by_title_and_foo)
+    assert ! Post.respond_to?(:find_all_by_title_and_foo)
+  end
+
+end
+
+class TwoTranslatedAttributesDynamicFindersTest < Test::Unit::TestCase
+
+  def setup
+    @title1, @title2, @content = "n1", "n2", "desc"
+    @p1 = Post.create!(:title => @title1, :content => @content)
+    @p2 = Post.create!(:title => @title2, :content => @content)
+  end
+
+  test "find one element by two translation columns" do
+    assert_equal @p1, Post.find_by_title_and_content(@title1, @content)
+    assert_equal @p2, Post.find_by_content_and_title(@content, @title2)
+  end
+
+  test "return nil for none existing values" do
+    assert_nil Post.find_by_content_and_title(@content, "not exisiting")
+    assert_nil Post.find_by_content_and_title("not existing", @title2)
+    
+    assert_nil Post.find_by_title_and_content("not exisiting", @content)
+    assert_nil Post.find_by_title_and_content(@title2, "not existing")
+  end
+
+  test "find elements by two translation columns" do
+    two_results = Post.find_all_by_title_and_content([@title1, @title2], @content)
+    assert two_results.include?(@p1)
+    assert two_results.include?(@p2)
+
+    assert_equal [@p2], Post.find_all_by_content_and_title(@content, @title2)
+  end
+
+  test "returns empty result set for none existing values" do
+    assert_equal [], Post.find_all_by_title_and_content([@title1, @title2], "not existing")
+    assert_equal [], Post.find_all_by_title_and_content("not existing", @content)
+
+    assert_equal [], Post.find_all_by_content_and_title(["not existing"], @title1)
+    assert_equal [], Post.find_all_by_content_and_title(@content, ["not existing"])
+  end
+
+end
+
+class TranslatedAndNormalAttributeDynamicFindersTest < Test::Unit::TestCase
+
+  def setup
+    @name1, @name2, @email = "n1", "n2", "email@example.org"
+    @p1 = User.create!(:name => @name1, :email => @email)
+    @p2 = User.create!(:name => @name2, :email => @email)
+  end
+
+  test "find one element by two columns" do
+    assert_equal @p1, User.find_by_name_and_email(@name1, @email)
+    assert_equal @p2, User.find_by_email_and_name(@email, @name2)
+  end
+
+  test "return nil for none existing values" do
+    assert_nil User.find_by_email_and_name(@email, "not exisiting")
+    assert_nil User.find_by_email_and_name("not existing", @name2)
+
+    assert_nil User.find_by_name_and_email("not exisiting", @email)
+    assert_nil User.find_by_name_and_email(@name2, "not existing")
+  end
+
+  test "find elements by two translation columns" do
+    two_results = User.find_all_by_name_and_email([@name1, @name2], @email)
+    assert two_results.include?(@p1)
+    assert two_results.include?(@p2)
+    assert_equal [@p2], User.find_all_by_email_and_name(@email, @name2)
+  end
+
+  test "returns empty result set for none existing values" do
+    assert_equal [], User.find_all_by_name_and_email([@name1, @name2], "not existing")
+    assert_equal [], User.find_all_by_name_and_email("not existing", @email)
+
+    assert_equal [], User.find_all_by_email_and_name(["not existing"], @name1)
+    assert_equal [], User.find_all_by_email_and_name(@email, ["not existing"])
+  end
+
+end