ui/base/ime/chromeos/component_extension_ime_manager_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/logging.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
   8 #include "ui/base/ime/chromeos/extension_ime_util.h"
   9 #include "ui/base/ime/chromeos/mock_component_extension_ime_manager_delegate.h"
  10
  11 namespace chromeos {
  12 namespace input_method {
  13
  14 namespace {
  15
  16 class ComponentExtensionIMEManagerTest : public testing::Test {
  17  public:
  18   ComponentExtensionIMEManagerTest() : mock_delegate_(NULL) {}
  19
  20   virtual void SetUp() {
  21     ime_list_.clear();
  22
  23     ComponentExtensionIME ext1;
  24     ext1.id = "ext1_id_xxxxxxxxxxxxxxxxxxxxxxxx";
  25     ext1.description = "ext1_description";
  26     ext1.options_page_url =
  27         GURL("chrome-extension://" + ext1.id + "/options.html");
  28     ext1.path = base::FilePath("ext1_file_path");
  29
  30     ComponentExtensionEngine ext1_engine1;
  31     ext1_engine1.engine_id = "zh-t-i0-pinyin";
  32     ext1_engine1.display_name = "ext1_engine_1_display_name";
  33     ext1_engine1.language_codes.push_back("zh-CN");
  34     ext1_engine1.layouts.push_back("us");
  35     ext1.engines.push_back(ext1_engine1);
  36
  37     ComponentExtensionEngine ext1_engine2;
  38     ext1_engine2.engine_id = "mozc_us";
  39     ext1_engine2.display_name = "ext1_engine2_display_name";
  40     ext1_engine2.language_codes.push_back("jp");
  41     ext1_engine2.layouts.push_back("us");
  42     ext1.engines.push_back(ext1_engine2);
  43
  44     ComponentExtensionEngine ext1_engine3;
  45     ext1_engine3.engine_id = "xkb:ru::rus";
  46     ext1_engine3.display_name = "ext1_engine3_display_name";
  47     ext1_engine3.language_codes.push_back("ru");
  48     ext1_engine3.layouts.push_back("ru");
  49     ext1.engines.push_back(ext1_engine3);
  50
  51     ime_list_.push_back(ext1);
  52
  53     ComponentExtensionIME ext2;
  54     ext2.id = "ext2_id_xxxxxxxxxxxxxxxxxxxxxxxx";
  55     ext2.description = "ext2_description";
  56     ext2.path = base::FilePath("ext2_file_path");
  57
  58     ComponentExtensionEngine ext2_engine1;
  59     ext2_engine1.engine_id = "vkd_ru_phone_aatseel";
  60     ext2_engine1.display_name = "ext2_engine_1_display_name";
  61     ext2_engine1.language_codes.push_back("ru");
  62     ext2_engine1.layouts.push_back("us");
  63     ext2.engines.push_back(ext2_engine1);
  64
  65     ComponentExtensionEngine ext2_engine2;
  66     ext2_engine2.engine_id = "vkd_vi_telex";
  67     ext2_engine2.display_name = "ext2_engine2_display_name";
  68     ext2_engine2.language_codes.push_back("hi");
  69     ext2_engine2.layouts.push_back("us");
  70     ext2.engines.push_back(ext2_engine2);
  71
  72     ComponentExtensionEngine ext2_engine3;
  73     ext2_engine3.engine_id = "xkb:us::eng";
  74     ext2_engine3.display_name = "ext2_engine3_display_name";
  75     ext2_engine3.language_codes.push_back("us");
  76     ext2_engine3.layouts.push_back("us");
  77     ext2.engines.push_back(ext2_engine3);
  78
  79     ime_list_.push_back(ext2);
  80
  81     ComponentExtensionIME ext3;
  82     ext3.id = "ext3_id_xxxxxxxxxxxxxxxxxxxxxxxx";
  83     ext3.description = "ext3_description";
  84     ext3.options_page_url =
  85     GURL("chrome-extension://" + ext3.id + "/options.html");
  86     ext3.path = base::FilePath("ext3_file_path");
  87
  88     ComponentExtensionEngine ext3_engine1;
  89     ext3_engine1.engine_id = "ext3_engine1_engine_id";
  90     ext3_engine1.display_name = "ext3_engine_1_display_name";
  91     ext3_engine1.language_codes.push_back("hi");
  92     ext3_engine1.layouts.push_back("us");
  93     ext3.engines.push_back(ext3_engine1);
  94
  95     ComponentExtensionEngine ext3_engine2;
  96     ext3_engine2.engine_id = "ext3_engine2_engine_id";
  97     ext3_engine2.display_name = "ext3_engine2_display_name";
  98     ext3_engine2.language_codes.push_back("en");
  99     ext3_engine2.layouts.push_back("us");
 100     ext3.engines.push_back(ext3_engine2);
 101
 102     ComponentExtensionEngine ext3_engine3;
 103     ext3_engine3.engine_id = "ext3_engine3_engine_id";
 104     ext3_engine3.display_name = "ext3_engine3_display_name";
 105     ext3_engine3.language_codes.push_back("en");
 106     ext3_engine3.layouts.push_back("us");
 107     ext3.engines.push_back(ext3_engine3);
 108
 109     ime_list_.push_back(ext3);
 110
 111     mock_delegate_ = new MockComponentExtIMEManagerDelegate();
 112     mock_delegate_->set_ime_list(ime_list_);
 113     component_ext_mgr_.reset(new ComponentExtensionIMEManager());
 114     component_ext_mgr_->Initialize(
 115         scoped_ptr<ComponentExtensionIMEManagerDelegate>(
 116             mock_delegate_).Pass());
 117   }
 118
 119   virtual void TearDown() {
 120   }
 121
 122  protected:
 123   MockComponentExtIMEManagerDelegate* mock_delegate_;
 124   scoped_ptr<ComponentExtensionIMEManager> component_ext_mgr_;
 125   std::vector<ComponentExtensionIME> ime_list_;
 126
 127  private:
 128
 129   DISALLOW_COPY_AND_ASSIGN(ComponentExtensionIMEManagerTest);
 130 };
 131
 132 TEST_F(ComponentExtensionIMEManagerTest, LoadComponentExtensionIMETest) {
 133   for (size_t i = 0; i < ime_list_.size(); ++i) {
 134     for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) {
 135       const std::string input_method_id =
 136           extension_ime_util::GetComponentInputMethodID(
 137               ime_list_[i].id,
 138               ime_list_[i].engines[j].engine_id);
 139       component_ext_mgr_->LoadComponentExtensionIME(NULL /* profile */,
 140                                                     input_method_id);
 141       EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_loaded_extension_id());
 142     }
 143   }
 144   EXPECT_EQ(9, mock_delegate_->load_call_count());
 145 }
 146
 147 TEST_F(ComponentExtensionIMEManagerTest, UnloadComponentExtensionIMETest) {
 148   for (size_t i = 0; i < ime_list_.size(); ++i) {
 149     for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) {
 150       const std::string input_method_id =
 151           extension_ime_util::GetComponentInputMethodID(
 152               ime_list_[i].id,
 153               ime_list_[i].engines[j].engine_id);
 154       component_ext_mgr_->UnloadComponentExtensionIME(NULL /* profile */,
 155                                                       input_method_id);
 156       EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_unloaded_extension_id());
 157     }
 158   }
 159   EXPECT_EQ(9, mock_delegate_->unload_call_count());
 160 }
 161
 162 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedTest) {
 163   EXPECT_TRUE(component_ext_mgr_->IsWhitelisted(
 164       extension_ime_util::GetComponentInputMethodID(
 165           ime_list_[0].id,
 166           ime_list_[0].engines[0].engine_id)));
 167   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 168       extension_ime_util::GetInputMethodID(
 169           ime_list_[0].id,
 170           ime_list_[0].engines[0].engine_id)));
 171   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted("mozc"));
 172   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 173       extension_ime_util::GetInputMethodID("AAAA", "012345")));
 174   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 175       extension_ime_util::GetComponentInputMethodID(
 176           "AAAA", "012345")));
 177 }
 178
 179 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedExtensionTest) {
 180   EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[0].id));
 181   EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[1].id));
 182   EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("dummy"));
 183   EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension(""));
 184 }
 185
 186 TEST_F(ComponentExtensionIMEManagerTest, GetAllIMEAsInputMethodDescriptor) {
 187   input_method::InputMethodDescriptors descriptors =
 188       component_ext_mgr_->GetAllIMEAsInputMethodDescriptor();
 189   size_t total_ime_size = 0;
 190   for (size_t i = 0; i < ime_list_.size(); ++i) {
 191     total_ime_size += ime_list_[i].engines.size();
 192   }
 193   EXPECT_EQ(total_ime_size, descriptors.size());
 194
 195   // Verify order
 196   for (size_t i = 0; i < descriptors.size(); ++i) {
 197     const input_method::InputMethodDescriptor& d = descriptors[i];
 198     if (i < 2) {
 199       EXPECT_TRUE(d.id().find("xkb:") != std::string::npos);
 200     } else if (i >= 2 && i < 4) {
 201       EXPECT_TRUE(d.id().find("vkd_") != std::string::npos);
 202     }
 203   }
 204 }
 205
 206 }  // namespace
 207
 208 }  // namespace input_method
 209 }  // namespace chromeos