lolita-i18n 0.3.2 → 0.4.0

data/lib/lolita-i18n/version.rb

@@ -0,0 +1,11 @@
+module Lolita
+  module I18n
+    class Version
+      VERSION = "0.4.0"
+
+      def self.to_s
+        VERSION
+      end
+    end
+  end
+end

data/lolita-i18n.gemspec

@@ -1,108 +1,30 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lolita-i18n/version"
 
 Gem::Specification.new do |s|
-  s.name = "lolita-i18n"
-  s.version = "0.3.2"
+  s.name        = "lolita-i18n"
+  s.version     = Lolita::I18n::Version.to_s
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["ITHouse (Latvia)", "Arturs Meisters", "Gatis Tomsons"]
+  s.email       = "support@ithouse.lv"
+  s.homepage    = "http://github.com/ithouse/lolita-i18n"
+  s.summary     = %q{Lolita plugin, that enables .yml management}
+  s.description = %q{Lolita plugin, that enables .yml files management from administrative interface. Also faster access to translations, that DB store}
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["ITHouse (Latvia)", "Arturs Meisters", "Gatis Tomsons"]
-  s.date = "2012-02-27"
-  s.description = "Lolita plugin, that enables .yml files management from administrative interface. Also faster access to translations, that DB store"
-  s.email = "support@ithouse.lv"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md"
   ]
-  s.files = [
-    ".document",
-    ".rspec",
-    "Gemfile",
-    "History.rdoc",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "app/assets/images/lolita/i18n/google_translate_icon.png",
-    "app/assets/javascripts/lolita/i18n/application.js",
-    "app/assets/javascripts/lolita/i18n/i18n.js.coffee",
-    "app/assets/javascripts/lolita/i18n/spin.min.js",
-    "app/assets/stylesheets/lolita/i18n/application.scss",
-    "app/controllers/lolita/i18n_controller.rb",
-    "app/helpers/lolita/i18n_helper.rb",
-    "app/views/lolita/i18n/index.html.haml",
-    "config/locales/en.yml",
-    "config/locales/lv.yml",
-    "config/routes.rb",
-    "lib/lolita-i18n.rb",
-    "lib/lolita-i18n/backend.rb",
-    "lib/lolita-i18n/exceptions.rb",
-    "lib/lolita-i18n/module.rb",
-    "lib/lolita-i18n/rails.rb",
-    "lolita-i18n.gemspec",
-    "spec/controllers/lolita/i18n_controller_spec.rb",
-    "spec/lolita-i18n/backend_spec.rb",
-    "spec/rails_app/app/controllers/application_controller.rb",
-    "spec/rails_app/config/application.rb",
-    "spec/rails_app/config/enviroment.rb",
-    "spec/rails_app/config/initializers/lolita_i18n.rb",
-    "spec/rails_app/config/locales/en.yml",
-    "spec/rails_app/config/locales/lv.yml",
-    "spec/rails_app/config/routes.rb",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = "http://github.com/ithouse/lolita-i18n"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
-  s.summary = "Lolita plugin, that enables .yml management"
-  s.test_files = [
-    "spec/controllers/lolita/i18n_controller_spec.rb",
-    "spec/lolita-i18n/backend_spec.rb",
-    "spec/rails_app/app/controllers/application_controller.rb",
-    "spec/rails_app/config/application.rb",
-    "spec/rails_app/config/enviroment.rb",
-    "spec/rails_app/config/initializers/lolita_i18n.rb",
-    "spec/rails_app/config/routes.rb",
-    "spec/spec_helper.rb"
-  ]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  s.add_runtime_dependency(%q<lolita>, ["~> 3.2.0.rc.9"])
+  s.add_runtime_dependency(%q<hiredis>, ["~> 0.3.1"])
+  s.add_runtime_dependency(%q<redis>, ["~> 2.2.2"])
+  s.add_runtime_dependency(%q<yajl-ruby>,["~> 1.0.0"])
+  s.add_runtime_dependency(%q<unicode_utils>,["~> 1.3.0"])
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<lolita>, ["~> 3.2.0.rc.6"])
-      s.add_runtime_dependency(%q<hiredis>, ["~> 0.3.1"])
-      s.add_runtime_dependency(%q<redis>, ["~> 2.2.2"])
-      s.add_runtime_dependency(%q<yajl-ruby>, ["~> 1.0.0"])
-      s.add_runtime_dependency(%q<easy_translate>, ["~> 0.2.1"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-    else
-      s.add_dependency(%q<lolita>, ["~> 3.2.0.rc.6"])
-      s.add_dependency(%q<hiredis>, ["~> 0.3.1"])
-      s.add_dependency(%q<redis>, ["~> 2.2.2"])
-      s.add_dependency(%q<yajl-ruby>, ["~> 1.0.0"])
-      s.add_dependency(%q<easy_translate>, ["~> 0.2.1"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<lolita>, ["~> 3.2.0.rc.6"])
-    s.add_dependency(%q<hiredis>, ["~> 0.3.1"])
-    s.add_dependency(%q<redis>, ["~> 2.2.2"])
-    s.add_dependency(%q<yajl-ruby>, ["~> 1.0.0"])
-    s.add_dependency(%q<easy_translate>, ["~> 0.2.1"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-  end
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
 end
-

data/spec/controllers/lolita/i18n_controller_spec.rb

@@ -1,30 +1,64 @@
-# coding: utf-8
-
-USE_RAILS=true unless defined?(USE_RAILS)
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-include Lolita::Test::Matchers
-
-describe Lolita::I18nController do
-  render_views
-
-  it "should have i18n routes" do
-    {:get=>"/lolita/i18n"}.should be_routable
-    {:put=>"/lolita/i18n/1"}.should be_routable
-    {:put=>"/lolita/i18n/translate_untranslated"}.should be_routable
-    {:get=>"/lolita/i18n"}.should be_routable
-  end
-
-  it "should show all translations" do
-    get :index
-    response.should render_template("index")
-    response.body.should match(/#{::I18n.t('lolita-i18n.title')}/)
-  end
-
-  it "should save translation" do
-    put :update, :id=>"en.Page title",:translation=>"New title", :format => :json
-    response.body.should == {error: false}.to_json
-    ::I18n.t("Page title", :locale => :en).should == "New title"
-  end
-
-end
+require 'spec_helper'
+
+describe Lolita::I18nController, :rails => true do 
+  
+  describe "GET index" do 
+    it "should authorize resource" do
+      controller.authorization_proxy.should_receive(:authorize!).with(:read,controller.resource_class)
+      get :index
+    end
+
+    it "should assign all translations to variable" do 
+      get :index
+      assigns[:translations].should be_kind_of(Hash)
+    end
+
+    it "should sort translations when params[:sort] is equal to 1" do 
+      i18n_request = double("i18n_request")
+      i18n_request.stub(:translations)
+      controller.stub(:i18n_request => i18n_request)
+      i18n_request.should_not_receive(:sort_translations)
+      get :index
+      i18n_request = double("i18n_request2")
+      i18n_request.stub(:translations)
+      controller.stub(:i18n_request => i18n_request)
+      i18n_request.should_receive(:sort_translations)
+      get :index, :sort => 1
+    end
+  end
+
+  describe "PUT update" do 
+    it "should authorize resource for update" do 
+      controller.authorization_proxy.should_receive(:authorize!).with(:update,controller.resource_class)
+      put :update, :id => "key", :translation => "translation", :format => :json
+    end
+
+    it "should create notice when save is successful" do 
+      controller.stub(:i18n_request => stub(:update_key => true))
+      controller.should_receive(:notice).with(kind_of(String))
+      put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
+    end
+
+    it "should create error when save is unsuccessful" do 
+      controller.stub(:i18n_request => stub(:update_key => false))
+      controller.should_receive(:error).with(kind_of(String))
+      put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
+    end
+
+    it "should render error when Lolita::I18n::Exceptions::MissingInterpolationArgument is raised" do 
+      i18n_request = double("request")
+      i18n_request.stub(:update_key).and_raise(Lolita::I18n::Exceptions::MissingInterpolationArgument.new(["%{count}"]))
+      controller.stub(:i18n_request => i18n_request)
+      put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
+      response.body.should eq(%q{{"error":"Translation should contain all these variables %{count}"}})
+    end
+
+    it "should render error when any other excption happens" do 
+      i18n_request = double("request")
+      i18n_request.stub(:update_key).and_raise(ArgumentError.new)
+      controller.stub(:i18n_request => i18n_request)
+      put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
+      response.body.should eq(%q{{"error":"Key is not saved. Some error accured."}})
+    end 
+  end
+end

data/spec/helpers/lolita/i18n_helper_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Lolita::I18nHelper, :rails => true do 
+  it "should return locale options" do 
+    good_locale_options = [
+      ["Choose other language",nil],
+      ["Latvian",:lv],
+      ["Russian",:ru]
+    ]
+    helper.locale_options.should eq(good_locale_options)
+  end
+
+  it "translation is visible when value is not blank and params does not say to show only untranslated values" do 
+    helper.translation_visible?("").should be_true
+    helper.translation_visible?("text").should be_true
+    helper.translation_visible?([]).should be_true
+    helper.translation_visible?({}).should be_true
+
+    helper.params[:show_untranslated] = true
+    helper.translation_visible?("").should be_true
+    helper.translation_visible?("text").should be_false
+    helper.translation_visible?([]).should be_true
+    helper.translation_visible?({}).should be_true
+  end
+
+  describe "#any_translation_visible?" do 
+    it "should detect if any translation from array is visible" do 
+      helper.any_translation_visible?([2,1]).should be_true
+      helper.any_translation_visible?([]).should be_true
+
+      helper.params[:show_untranslated] = true
+      helper.any_translation_visible?([]).should be_true
+      helper.any_translation_visible?(["",1]).should be_true
+      helper.any_translation_visible?(["a","b"]).should be_false
+    end
+
+
+    it "should detect if any translation from hash is visible" do 
+      helper.any_translation_visible?({:a => "1",:b => "2" }).should be_true
+      helper.any_translation_visible?([]).should be_true
+
+      helper.params[:show_untranslated] = true
+      helper.any_translation_visible?({}).should be_true
+      helper.any_translation_visible?({:a => "1",:b => "2" }).should be_false
+      helper.any_translation_visible?({:a => "1",:b => "" }).should be_true
+    end
+
+    it "should call #translation_visible? for any other value" do 
+      helper.should_receive(:translation_visible?).with("text")
+      helper.any_translation_visible?("text")
+    end
+  end
+
+  describe "#sort_link" do 
+    before(:each) do 
+      {:controller => "lolita/i18n",:action => "index", :i18n_locale => :en}.each do |k,v|
+        helper.params[k] = v
+      end
+    end
+    it "should create link with sort in it when params does not include :sort" do 
+      helper.sort_link.should match(/sort=1/)
+    end
+
+    it "should create link witho sort in it when params include :sort"  do 
+      helper.params[:sort] = "1"
+      helper.sort_link.should_not match(/sort=1/)
+    end
+  end
+
+end

data/spec/lolita-i18n/configuration_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Lolita::I18n::Configuration do 
+  let(:klass){Lolita::I18n::Configuration}
+  let(:conf){klass.new}
+  let(:redis){double("redis")}
+
+  it "should load rails if Rails is defined" do 
+    Lolita.stub(:rails3?).and_return(true)
+    conf.should_receive(:require).with('lolita-i18n/rails')
+    conf.load_rails!
+  end
+
+  it "should allow to assign store with Hash as connection options" do 
+    Redis.should_receive(:new).with({:key => "value"}).and_return(redis)
+    conf.store={:key => "value"}
+  end
+
+  it "should allow to assign store as store itself" do 
+    conf.store = redis 
+    conf.store.should eq(redis)
+  end
+
+  it "should return assigned store" do 
+    conf.store = redis
+    conf.store.should eq(redis)
+  end
+
+  it "should return new Redis connection and warn when no store is assigned"  do 
+    Redis.should_receive(:new).and_return(redis)
+    conf.should_receive(:warn).with("Lolita::I18n No store specified. See Lolita::I18n")
+    conf.store.should eq(redis)
+  end
+
+  it "should lazy create and return backend" do 
+    Redis.should_receive(:new).and_return(redis)
+    ::I18n::Backend::KeyValue.should_receive(:new).with(redis)
+    conf.backend
+  end
+
+  it "should load translations" do 
+    yaml_backend = double("yaml_backend")
+    conf.yaml_backend = yaml_backend
+    yaml_backend.should_receive(:load_translations)
+    conf.load_translations
+  end
+
+  it "should initialize chain" do 
+    conf.yaml_backend = double("yaml backend")
+    Redis.stub(:new).and_return(redis)
+    ::I18n::Backend::Chain.should_receive(:new).with(conf.backend,conf.yaml_backend)
+    conf.initialize_chain
+  end
+
+  it "include module in ::I18n::Backend::Simple" do 
+    conf.include_modules
+    ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::Flatten)
+    ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::Pluralization)
+    ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::Metadata)
+    ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::InterpolationCompiler)
+  end
+
+end

data/spec/lolita-i18n/exceptions_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Lolita::I18n::Exceptions::MissingInterpolationArgument do 
+  it "create new StandartError with custom message" do 
+    error = Lolita::I18n::Exceptions::MissingInterpolationArgument.new(["arg1","arg2"])
+    error.message.should eq("Translation should contain all these variables arg1, arg2")
+  end
+end
+
+describe Lolita::I18n::Exceptions::TranslationDoesNotMatch do 
+  it "should cretae new ArgumentError with custom message" do 
+    error = Lolita::I18n::Exceptions::TranslationDoesNotMatch.new("translation", "original")
+    error.message.should eq("Translation translation does not match original")
+  end
+end

data/spec/lolita-i18n/request_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe Lolita::I18n::Request do 
+
+  describe Lolita::I18n::Request::Validator do 
+    let(:validator){Lolita::I18n::Request::Validator.new}
+
+    it "should validate string and return error when original and given values interpolations doesn't match" do
+      ::I18n.stub(:t).and_return("original text")
+      expect{validator.validate("text_key","text")}.not_to raise_error
+
+      ::I18n.stub(:t).and_return("text with %{interpolation}")
+      expect{
+        validator.validate("text_key","text")
+      }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument)
+    end
+
+    it "should validate array's each value as string" do 
+      ::I18n.stub(:t).and_return(["a","b","c"])
+      expect{validator.validate("array_key",["1","2","3"])}.not_to raise_error
+
+      ::I18n.stub(:t).and_return(["a","%{b}","c"])
+      expect{
+        validator.validate("array_key",["1","2","3"])
+      }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument,"Translation should contain all these variables %{b}")
+    end
+
+    it "should validate hash's each value as string" do 
+      ::I18n.stub(:t).and_return({:a => "1", :b => "2"})
+      expect{validator.validate("array_key",{"a" => "a", "b" => "b"})}.not_to raise_error
+
+      ::I18n.stub(:t).and_return({:a => "1", :b => "2 %{count}"})
+      expect{
+        validator.validate("array_key",{"a" => "a", "b" => "b"})
+      }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument)
+    end
+
+    it "should raise error when translation is Array but original is not or sizes does not match" do 
+      ::I18n.stub(:t).and_return("")
+      expect{
+        validator.validate("key",[1,2])
+      }.to raise_error(Lolita::I18n::Exceptions::TranslationDoesNotMatch)
+
+      ::I18n.stub(:t).and_return([1,2])
+      expect{
+        validator.validate("key",[2])
+      }
+    end
+
+    it "should raise error when translation is Hash but original is not or keys does not match " do 
+      ::I18n.stub(:t).and_return("")
+      expect{
+        validator.validate("key",{"a" => 1})
+      }.to raise_error(Lolita::I18n::Exceptions::TranslationDoesNotMatch)
+      ::I18n.stub(:t).and_return({:a => 2, :b => 3})
+      expect{
+        validator.validate("key",{"a" => 1})
+      }
+    end
+  end
+
+  describe Lolita::I18n::Request::Translation do 
+    let(:klass){Lolita::I18n::Request::Translation}
+
+    it "should create new with key and translation as Array,Hash or String" do 
+      expect{
+        Lolita::I18n::Request::Translation.new("key","value")
+        Lolita::I18n::Request::Translation.new("key", ["value"])
+        Lolita::I18n::Request::Translation.new("key", {:hkey => "value"})
+      }.not_to raise_error
+    end
+
+    it "should return parsed value" do 
+      I18n.stub(:t).and_return("original_value")
+      t = klass.new("key","value")
+      t.value.should eq("value")
+    end
+
+    it "should return locale for key" do 
+      t = klass.new("lv.key","value")
+      t.locale.should eq(:lv)
+    end
+
+    it "should return key" do 
+      t = klass.new("lv.key","value")
+      t.key.should eq("key")
+    end
+
+    it "should return array for store with locale, key => value and configuration hash" do 
+      t = klass.new("lv.my.key","value")
+      t.for_store.should eq([:lv,{"my.key" => "value"}, {:escape => false}])
+    end
+
+    it "should return original translation of given key" do 
+      ::I18n.stub(:t).with(kind_of(String), kind_of(Hash)).and_return("original")
+      t = klass.new("ru.my.key","value")
+      t.original.should eq("original")
+    end
+  end
+
+
+  describe Lolita::I18n::Request::Translations do 
+    before(:each) do 
+      ::I18n.locale = :en
+    end
+
+    let(:klass){Lolita::I18n::Request::Translations}
+    let(:translations) {
+      ::I18n.stub(:t) do |*args|
+        if args[1] && args[1][:locale] == :en
+          if args[0] == :arr
+            [1,2] 
+          elsif args[0] == :str
+            "string"
+          elsif args[0] == :inter
+            {:one => "one",:other => "other"} 
+          elsif args[0] == :"hsh.key"
+            "value" 
+          end
+        else
+          "-no-translation-"
+        end
+      end
+      {:arr => [1,2], :str => "string", :inter => {:one => "one",:other => "other"}, :hsh => {:key => "value"}}
+    }
+
+    it "should create new with hash" do 
+      expect{
+        klass.new({})
+      }.not_to raise_error
+    end
+
+    it "should detect if value is final and should't be flattened any more" do
+      t = klass.new({})
+      t.final_value?(1).should be_true
+      t.final_value?([]).should be_true
+      t.final_value?({:other => "other", :one => "one"}).should be_true
+      t.final_value?({:other => "other"}).should be_false
+      t.final_value?({:other => [], :one => 1}).should be_false
+      t.final_value?({:other => {}, :one => 1}).should be_false
+    end
+
+    it "should return default translation value for different original values" do 
+      t = klass.new({})
+      ::I18n.stub(:t).and_return([])
+      t.translation_value("key",[1,2],"ru").should eq([])
+      ::I18n.stub(:t).and_return({})
+      t.translation_value("key",{:a=>1},"ru").should eq({})
+      ::I18n.stub(:t).and_return("translation")
+      t.translation_value("key","value","ru").should eq("translation")
+      ::I18n.stub(:t).and_return([1,2])
+      t.translation_value("key",[2,3],"ru").should eq([1,2])
+    end
+
+    it "should flatten keys until final value is found" do 
+      t = klass.new({})
+      result = []
+      t.flatten_keys(translations, :lv) do |key,translation_value,original_value|
+        result << [key,translation_value,original_value]
+      end
+      valid_results = [
+        [:arr, [], [1,2]],
+        [:str, "-no-translation-", "string"],
+        [:inter, {}, {:one => "one", :other => "other"}],
+        [:"hsh.key","-no-translation-", "value"]
+      ]
+      result.should eq(valid_results)
+    end 
+
+    it "should normalize for locale" do 
+      t = klass.new(translations)
+      valid_results = {
+        :arr => {:translation => [], :original_translation => [1,2]},
+        :str => {:translation => "-no-translation-", :original_translation => "string"},
+        :inter => {:translation => {}, :original_translation => {:one => "one", :other => "other"}},
+        :"hsh.key" => {:translation => "-no-translation-", :original_translation => "value"}
+      }
+      t.normalized(:lv).should eq(valid_results)
+    end
+
+  end
+
+  let(:request_klass){Lolita::I18n::Request}
+
+  it "should create new request with params" do 
+    expect{
+      request = request_klass.new({:a => 1})
+      request.params.should eq({:a => 1})
+    }.not_to raise_error
+  end
+
+  it "should return translations" do 
+    r = request_klass.new({})
+    Lolita.i18n.should_receive(:load_translations).and_return(true)
+    Lolita.i18n.stub(:yaml_backend).and_return(stub(:translations => {:en => {}}))
+    Lolita::I18n::Request::Translations.any_instance.should_receive(:normalized).once
+    r.translations(:en)
+  end
+
+  it "should sort translations" do 
+    r = request_klass.new({})
+    unsorted_translations = {
+      :"key9" => {:original_translation => "ZZZ"},
+      :"key8" => {:original_translation => [1,2]},
+      :"key7" => {:original_translation => {:a => 1}},
+      :"key6" => {:original_translation => "aaa"},
+      :"key5" => {:original_translation => nil},
+      :"key4" => {:original_translation => true}, 
+      :"key3" => {:original_translation => false}
+    }
+    sorted_translations = [
+      [:"key7", {:original_translation => {:a => 1}}],
+      [:"key8", {:original_translation => [1,2]}],
+      [:"key5", {:original_translation => nil}],
+      [:"key6", {:original_translation => "aaa"}],
+      [:"key3", {:original_translation => false}],
+      [:"key4", {:original_translation => true}], 
+      [:"key9", {:original_translation => "ZZZ"}]
+    ]
+    r.sort_translations(unsorted_translations).should eq(sorted_translations)
+  end
+
+  it "should update key" do 
+    r = request_klass.new({:translation => "translation", :id => Base64.encode64("ru.key")})
+    ::I18n.stub(:t).and_return("original")
+    backend = double("backend")
+    Lolita.i18n.stub(:backend => backend)
+    backend.should_receive(:store_translations).with(:"ru", { "key" => "translation" }, :escape => false).and_return(true)
+    r.update_key
+  end
+
+  it "should have validator" do 
+    r = request_klass.new({})
+    r.validator.should be_a_kind_of(Lolita::I18n::Request::Validator)
+  end
+
+ 
+end