galetahub-globalize3 0.2.1

data/test/globalize3/validations_test.rb

@@ -0,0 +1,92 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ValidationsTest < Test::Unit::TestCase
+  def teardown
+    super
+    Validatee.reset_callbacks(:validate)
+  end
+  
+  # TODO
+  #
+  # test "a record with valid values on non-default locale validates" do
+  #   assert Post.create(:title => 'foo', :locale => :de).valid?
+  # end
+
+  test "update_attribute succeeds with valid values" do
+    post = Post.create(:title => 'foo')
+    post.update_attributes(:title => 'baz')
+    assert post.valid?
+    assert_equal 'baz', Post.first.title
+  end
+
+  test "update_attributes fails with invalid values" do
+    post = Post.create(:title => 'foo')
+    assert !post.update_attributes(:title => '')
+    assert !post.valid?
+    assert_not_nil post.reload.attributes['title']
+    assert_equal 'foo', post.title
+  end
+
+  test "validates_presence_of" do
+    Validatee.class_eval { validates_presence_of :string }
+    assert !Validatee.new.valid?
+    assert Validatee.new(:string => 'foo').valid?
+  end
+
+  test "validates_confirmation_of" do
+    Validatee.class_eval { validates_confirmation_of :string }
+    assert !Validatee.new(:string => 'foo', :string_confirmation => 'bar').valid?
+    assert Validatee.new(:string => 'foo', :string_confirmation => 'foo').valid?
+  end
+
+  test "validates_acceptance_of" do
+    Validatee.class_eval { validates_acceptance_of :string, :accept => '1' }
+    assert !Validatee.new(:string => '0').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+  
+  test "validates_length_of (:is)" do
+    Validatee.class_eval { validates_length_of :string, :is => 1 }
+    assert !Validatee.new(:string => 'aa').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_format_of" do
+    Validatee.class_eval { validates_format_of :string, :with => /^\d+$/ }
+    assert !Validatee.new(:string => 'a').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+  
+  test "validates_inclusion_of" do
+    Validatee.class_eval { validates_inclusion_of :string, :in => %(a) }
+    assert !Validatee.new(:string => 'b').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_exclusion_of" do
+    Validatee.class_eval { validates_exclusion_of :string, :in => %(b) }
+    assert !Validatee.new(:string => 'b').valid?
+    assert Validatee.new(:string => 'a').valid?
+  end
+  
+  test "validates_numericality_of" do
+    Validatee.class_eval { validates_numericality_of :string }
+    assert !Validatee.new(:string => 'a').valid?
+    assert Validatee.new(:string => '1').valid?
+  end
+
+  # This doesn't pass and Rails' validates_uniqueness_of implementation doesn't
+  # seem to be extensible easily. One can work around that by either defining
+  # a custom validation on the Validatee model itself, or by using validates_uniqueness_of
+  # on Validatee::Translation.
+  # 
+  # test "validates_uniqueness_of" do
+  #   Validatee.class_eval { validates_uniqueness_of :string }
+  #   Validatee.create!(:string => 'a')
+  #   assert !Validatee.new(:string => 'a').valid?
+  #   assert Validatee.new(:string => 'b').valid?
+  # end
+
+  # test "validates_associated" do
+  # end
+end

data/test/globalize3/versioning_test.rb

@@ -0,0 +1,87 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class VersioningTest < Test::Unit::TestCase
+  test "versions are scoped to the current Globalize locale" do
+    post = Post.create!(:title => 'title v1', :content => '')
+    post.update_attributes!(:title => 'title v2')
+    # Creates a 'created' version, an initial update, and the update
+    assert_equal ['en', 'en', 'en'], post.versions.map(&:locale)
+
+    Globalize.locale = :de
+    post.update_attributes!(:title => 'Titel v1')
+    assert_equal ['de', 'de'], post.versions.map(&:locale)
+
+    Globalize.locale = :en
+    post.versions.reset # hrmmm.
+    assert_equal ['en', 'en', 'en'], post.versions.map(&:locale)
+  end
+
+  test "does not create a version for initial locale" do
+    # really ?
+  end
+
+  test "reverting to an earlier version only reverts changes to the current locale" do
+    post = Post.create!(:title => 'title v1', :content => '')
+    post.update_attributes!(:title => 'title v2')
+    post.update_attributes!(:title => 'Titel v1', :locale => :de)
+    post.update_attributes!(:title => 'title v3')
+
+    # Roll back 2 versions in default locale
+    post.rollback
+    post.rollback
+
+    assert_equal 'title v1', post.title(:en)
+    assert_equal 'Titel v1', post.title(:de)
+  end
+
+  test "reverting happens per locale" do
+    post = Post.create!(:title => 'title v1')
+
+    with_locale(:en) do
+      post.update_attributes!(:title => 'title v2')
+    end
+
+    with_locale(:de) do
+      post.update_attributes!(:title => 'Titel v1')
+    end
+
+    with_locale(:en) do
+      post.update_attributes!(:title => 'title v3', :published => true)
+      assert post.published?
+    end
+
+    with_locale(:de) do
+      post.update_attributes!(:title => 'Titel v2')
+      assert !post.published?
+    end
+
+    with_locale(:en) do
+      post.rollback
+      assert_equal 'title v2', post.title
+      assert !post.published?
+
+      post.rollback
+      assert_equal 'title v1', post.title
+      assert !post.published?
+    end
+
+    with_locale(:de) do
+      post.rollback
+      assert_equal 'Titel v1', post.title
+      assert !post.published?
+    end
+
+    with_locale(:en) do
+      assert_equal 'title v1', post.title
+      assert !post.published?
+    end
+  end
+
+  # test "versioning with vestal_versions works (using update_attribute)" do
+  #   post = Post.create!(:title => 'title', :content => '')
+  #   assert_equal 1, post.version
+  #
+  #   assert post.update_attribute(:title, 'changed title')
+  #   assert_equal 2, post.version
+  # end
+end

data/test/globalize3_test.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class Globalize3Test < Test::Unit::TestCase
+  test "a translated record has many translations" do
+    assert_has_many(Post, :translations)
+  end
+
+  test "translations are empty for a new record" do
+    assert_equal [], Post.new.translations
+  end
+
+  test "create uses the given locale" do
+    post = Post.create(:title => 'Titel', :locale => :de)
+    assert_translated post, :de, :title, 'Titel'
+  end
+
+  test "can translate boolean values" do
+    post = Post.create(:title => 'Titel', :published => true, :locale => :de)
+    assert_translated post, :de, :published, true
+  end
+
+  test "can translate datetime values" do
+    now = Time.now
+    post = Post.create(:title => 'Titel', :published_at => now, :locale => :de)
+    assert_translated post, :de, :published_at, now
+  end
+
+  test "attributes= uses the given locale" do
+    post = Post.create(:title => 'title')
+    post.attributes = { :title => 'Titel', :locale => :de }
+    post.save
+    post.reload
+
+    assert_equal 2, post.translations.size
+    assert_translated post, :de, :title, 'Titel'
+    assert_translated post, :en, :title, 'title'
+  end
+
+  test "create on associations works" do
+    blog = Blog.create
+    blog.posts.create(:title => 'title')
+    blog.posts.create(:title => 'Titel', :locale => :de)
+
+    assert_equal 2, blog.posts.size
+    assert_translated blog.posts.first, :en, :title, 'title'
+    assert_translated blog.posts.last,  :de, :title, 'Titel'
+  end
+
+  test "named scopes work" do
+    post = Blog.create.posts.create(:title => 'some title')
+    post.reload
+
+    assert_translated post, :en, :title, 'some title'
+  end
+
+  test "saves a translations record for each locale using a given locale" do
+    post = Post.create(:title => 'Titel', :locale => :de)
+    post.update_attributes(:title => 'title', :locale => :en)
+
+    assert_equal 2, post.translations.size
+    assert_translated post, :de, :title, 'Titel'
+    assert_translated post, :en, :title, 'title'
+  end
+
+  test "saves a translations record for each locale using the current I18n locale" do
+    post = with_locale(:de) { Post.create(:title => 'Titel') }
+    with_locale(:en) { post.update_attributes(:title => 'title') }
+
+    assert_equal 2, post.translations.size
+    assert_translated post, :en, :title, 'title'
+    assert_translated post, :de, :title, 'Titel'
+  end
+
+  test "reload works with translated attributes" do
+    post = Post.create(:title => 'foo')
+    post.title = 'baz'
+    post.reload
+    assert_equal 'foo', post.title
+  end
+
+  test "reload accepts standard finder options" do
+    post = Post.create(:title => "title")
+    assert post.reload(:readonly => true, :lock => true)
+    assert_raise(ArgumentError) { post.reload(:foo => :bar) }
+  end
+
+  test "destroy destroys dependent translations" do
+    post = Post.create(:title => "title")
+    post.update_attributes(:title => 'Titel', :locale => :de)
+    assert_equal 2, PostTranslation.count
+    post.destroy
+    assert_equal 0, PostTranslation.count
+  end
+
+  test "to_xml includes translated fields" do
+    post = Post.create(:title => "foo", :content => "bar")
+    post.reload
+    assert post.to_xml =~ %r(<title>foo</title>)
+    assert post.to_xml =~ %r(<content>bar</content>)
+  end
+
+  test "to_xml doesn't affect untranslated models" do
+    blog = Blog.create(:description => "my blog")
+    blog.reload
+    assert blog.to_xml =~ %r(<description>my blog</description>)
+  end
+
+  test "translated_locales returns locales that have translations" do
+    first = Post.create!(:title => 'title', :locale => :en)
+    first.update_attributes(:title => 'Title', :locale => :de)
+
+    second = Post.create!(:title => 'title', :locale => :en)
+    second.update_attributes(:title => 'titre', :locale => :fr)
+
+    assert_equal [:de, :en, :fr], Post.translated_locales
+    assert_equal [:de, :en], first.translated_locales
+    assert_equal [:en, :fr], second.translated_locales
+
+    first.reload
+    second.reload
+
+    assert_equal [:de, :en], first.translated_locales
+    assert_equal [:en, :fr], second.translated_locales
+  end
+
+  test "a model with an after_save callback that reloads the model still saves correctly" do
+    reloading_post = ReloadingPost.create!(:title => 'title')
+    assert_equal 'title', reloading_post.title
+    assert_translated reloading_post, :en, :title, 'title'
+  end
+
+  test "with_translations eager loads translations" do
+    Post.create(:title => 'title 1')
+    Post.create(:title => 'title 2')
+
+    assert Post.with_translations.first.translations.loaded?
+    assert_equal ['title 1', 'title 2'], Post.with_translations.map(&:title)
+  end
+
+
+  test "a subclass of an untranslated model can translate attributes" do
+    post = Post.create(:title => 'title')
+    translated_comment = TranslatedComment.create(:post => post, :content => 'content')
+
+    assert_nothing_raised { translated_comment.translations }
+    assert_translated translated_comment, :en, :content, 'content'
+  end
+
+  test "modifiying translated attributes on a subclass of an untranslated model works" do
+    post = Post.create(:title => 'title')
+    translated_comment = TranslatedComment.create(:post => post, :content => 'content')
+
+    assert translated_comment.update_attributes(:content => 'Inhalt', :locale => :de)
+    assert_translated translated_comment, :en, :content, 'content'
+    assert_translated translated_comment, :de, :content, 'Inhalt'
+  end
+end

data/test/i18n/missing_translations_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'i18n/missing_translations_log_handler'
+
+class TestLogger < String
+  def warn(msg) self.concat msg; end
+end
+
+class LogMissingTranslationsTest < Test::Unit::TestCase
+  def setup
+    @locale, @key, @options = :en, :foo, {}
+    @exception = I18n::MissingTranslationData.new(@locale, @key, @options)
+    
+    @logger = TestLogger.new
+    I18n.missing_translations_logger = @logger
+    super
+  end
+
+  test "defines I18n.missing_translations_logger accessor" do
+    assert I18n.respond_to?(:missing_translations_logger)
+  end
+
+  test "defines I18n.missing_translations_logger= writer" do
+    assert I18n.respond_to?(:missing_translations_logger=)
+  end
+
+  test "still returns the exception message for MissingTranslationData exceptions" do
+    result = I18n.send(:missing_translations_log_handler, @exception, @locale, @key, @options)
+    assert_match /translation missing: en(\W+)foo/, result
+  end
+  
+  test "logs the missing translation to I18n.missing_translations_logger" do
+    I18n.send(:missing_translations_log_handler, @exception, @locale, @key, @options)
+    assert_match /translation missing: en(\W+)foo/, @logger
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'fileutils'
+require 'logger'
+
+Bundler.require(:default, :test)
+require 'database_cleaner'
+require 'test_declarative'
+
+log = '/tmp/globalize3_test.log'
+FileUtils.touch(log) unless File.exists?(log)
+ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)
+ActiveRecord::Base.logger = Logger.new(log)
+ActiveRecord::LogSubscriber.attach_to(:active_record)
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'globalize'
+# require 'globalize/versioning/vestal_versions'
+require 'erb'
+
+require File.expand_path('../data/schema', __FILE__)
+require File.expand_path('../data/models', __FILE__)
+
+DatabaseCleaner.strategy = :truncation
+
+class Test::Unit::TestCase
+  def setup
+    I18n.locale = :en
+    Globalize.locale = nil
+    DatabaseCleaner.start
+  end
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+
+  def with_locale(*args, &block)
+    Globalize.with_locale(*args, &block)
+  end
+
+  def with_fallbacks
+    previous = I18n.backend
+    I18n.backend = BackendWithFallbacks.new
+    I18n.pretend_fallbacks
+    return yield
+  ensure
+    I18n.hide_fallbacks
+    I18n.backend = previous
+  end
+
+  def assert_included(item, array)
+    assert_block "Item #{item.inspect} is not included in the array #{array.inspect}" do
+      array.include?(item)
+    end
+  end
+
+  def assert_belongs_to(model, other)
+    assert_association(model, :belongs_to, other)
+  end
+
+  def assert_has_many(model, other)
+    assert_association(model, :has_many, other)
+  end
+
+  def assert_association(model, type, other)
+    assert model.reflect_on_all_associations(type).any? { |a| a.name.to_s == other.to_s }
+  end
+
+  def assert_translated(record, locale, attributes, translations)
+    assert_equal Array.wrap(translations), Array.wrap(attributes).map { |name| record.send(name, locale) }
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  class << self
+    def index_exists?(index_name)
+      connection.indexes(table_name).any? { |index| index.name == index_name.to_s }
+    end
+
+    def index_exists_on?(column_name)
+      connection.indexes(table_name).any? { |index| index.columns == [column_name.to_s] }
+    end
+  end
+end
+
+class BackendWithFallbacks < I18n::Backend::Simple
+  include I18n::Backend::Fallbacks
+end
+
+meta = class << I18n; self; end
+meta.class_eval do
+  alias_method(:alternatives, :fallbacks)
+
+  def pretend_fallbacks
+    class << I18n; self; end.send(:alias_method, :fallbacks, :alternatives)
+  end
+
+  def hide_fallbacks
+    class << I18n; self; end.send(:remove_method, :fallbacks)
+  end
+end
+
+I18n.hide_fallbacks