chromeos/ime/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 "chromeos/ime/component_extension_ime_manager.h"
   7 #include "chromeos/ime/extension_ime_util.h"
   8 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace chromeos {
  12 namespace input_method {
  13
  14 namespace {
  15
  16 class TestableComponentExtensionIMEManager
  17     : public ComponentExtensionIMEManager {
  18  public:
  19   using ComponentExtensionIMEManager::GetComponentExtensionIMEId;
  20 };
  21
  22 class ComponentExtensionIMEManagerTest :
  23     public testing::Test,
  24     public ComponentExtensionIMEManager::Observer {
  25  public:
  26   ComponentExtensionIMEManagerTest()
  27       : mock_delegate_(NULL),
  28         on_initialized_callcount_(0) {
  29   }
  30
  31   virtual void SetUp() {
  32     ime_list_.clear();
  33
  34     ComponentExtensionIME ext1;
  35     ext1.id = "ext1_id";
  36     ext1.description = "ext1_description";
  37     ext1.options_page_url =
  38         GURL("chrome-extension://" + ext1.id + "/options.html");
  39     ext1.path = base::FilePath("ext1_file_path");
  40
  41     ComponentExtensionEngine ext1_engine1;
  42     ext1_engine1.engine_id = "ext1_engine1_engine_id";
  43     ext1_engine1.display_name = "ext1_engine_1_display_name";
  44     ext1_engine1.language_code = "en";
  45     ext1_engine1.layouts.push_back("us");
  46     ext1.engines.push_back(ext1_engine1);
  47
  48     ComponentExtensionEngine ext1_engine2;
  49     ext1_engine2.engine_id = "ext1_engine2_engine_id";
  50     ext1_engine2.display_name = "ext1_engine2_display_name";
  51     ext1_engine2.language_code = "en";
  52     ext1_engine2.layouts.push_back("us");
  53     ext1.engines.push_back(ext1_engine2);
  54
  55     ComponentExtensionEngine ext1_engine3;
  56     ext1_engine3.engine_id = "ext1_engine3_engine_id";
  57     ext1_engine3.display_name = "ext1_engine3_display_name";
  58     ext1_engine3.language_code = "ja";
  59     ext1_engine3.layouts.push_back("us");
  60     ext1.engines.push_back(ext1_engine3);
  61
  62     ime_list_.push_back(ext1);
  63
  64     ComponentExtensionIME ext2;
  65     ext2.id = "ext2_id";
  66     ext2.description = "ext2_description";
  67     ext2.path = base::FilePath("ext2_file_path");
  68
  69     ComponentExtensionEngine ext2_engine1;
  70     ext2_engine1.engine_id = "ext2_engine1_engine_id";
  71     ext2_engine1.display_name = "ext2_engine_1_display_name";
  72     ext2_engine1.language_code = "en";
  73     ext2_engine1.layouts.push_back("us");
  74     ext2.engines.push_back(ext2_engine1);
  75
  76     ComponentExtensionEngine ext2_engine2;
  77     ext2_engine2.engine_id = "ext2_engine2_engine_id";
  78     ext2_engine2.display_name = "ext2_engine2_display_name";
  79     ext2_engine2.language_code = "hi";
  80     ext2_engine2.layouts.push_back("us");
  81     ext2.engines.push_back(ext2_engine2);
  82
  83     ComponentExtensionEngine ext2_engine3;
  84     ext2_engine3.engine_id = "ext2_engine3_engine_id";
  85     ext2_engine3.display_name = "ext2_engine3_display_name";
  86     ext2_engine3.language_code = "ja";
  87     ext2_engine3.layouts.push_back("jp");
  88     ext2.engines.push_back(ext2_engine3);
  89
  90     ime_list_.push_back(ext2);
  91
  92     ComponentExtensionIME ext3;
  93     ext3.id = "ext3_id";
  94     ext3.description = "ext3_description";
  95     ext1.options_page_url =
  96         GURL("chrome-extension://" + ext3.id + "/options.html");
  97     ext3.path = base::FilePath("ext3_file_path");
  98
  99     ComponentExtensionEngine ext3_engine1;
 100     ext3_engine1.engine_id = "ext3_engine1_engine_id";
 101     ext3_engine1.display_name = "ext3_engine_1_display_name";
 102     ext3_engine1.language_code = "hi";
 103     ext3_engine1.layouts.push_back("us");
 104     ext3.engines.push_back(ext3_engine1);
 105
 106     ComponentExtensionEngine ext3_engine2;
 107     ext3_engine2.engine_id = "ext3_engine2_engine_id";
 108     ext3_engine2.display_name = "ext3_engine2_display_name";
 109     ext3_engine2.language_code = "en";
 110     ext3_engine2.layouts.push_back("us");
 111     ext3.engines.push_back(ext3_engine2);
 112
 113     ComponentExtensionEngine ext3_engine3;
 114     ext3_engine3.engine_id = "ext3_engine3_engine_id";
 115     ext3_engine3.display_name = "ext3_engine3_display_name";
 116     ext3_engine3.language_code = "en";
 117     ext3_engine3.layouts.push_back("us");
 118     ext3.engines.push_back(ext3_engine3);
 119
 120     ime_list_.push_back(ext3);
 121
 122     mock_delegate_ = new MockComponentExtIMEManagerDelegate();
 123     mock_delegate_->set_ime_list(ime_list_);
 124     component_ext_mgr_.reset(new ComponentExtensionIMEManager());
 125     component_ext_mgr_->AddObserver(this);
 126     EXPECT_FALSE(component_ext_mgr_->IsInitialized());
 127     component_ext_mgr_->Initialize(
 128         scoped_ptr<ComponentExtensionIMEManagerDelegate>(
 129             mock_delegate_).Pass());
 130     EXPECT_TRUE(component_ext_mgr_->IsInitialized());
 131
 132   }
 133
 134   virtual void TearDown() {
 135     EXPECT_EQ(1, on_initialized_callcount_);
 136     component_ext_mgr_->RemoveObserver(this);
 137   }
 138
 139  protected:
 140   MockComponentExtIMEManagerDelegate* mock_delegate_;
 141   scoped_ptr<ComponentExtensionIMEManager> component_ext_mgr_;
 142   std::vector<ComponentExtensionIME> ime_list_;
 143
 144  private:
 145   virtual void OnInitialized() OVERRIDE {
 146     ++on_initialized_callcount_;
 147   }
 148
 149   int on_initialized_callcount_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(ComponentExtensionIMEManagerTest);
 152 };
 153
 154 TEST_F(ComponentExtensionIMEManagerTest, LoadComponentExtensionIMETest) {
 155   for (size_t i = 0; i < ime_list_.size(); ++i) {
 156     for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) {
 157       const std::string input_method_id =
 158           TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 159               ime_list_[i].id,
 160               ime_list_[i].engines[j].engine_id);
 161       component_ext_mgr_->LoadComponentExtensionIME(input_method_id);
 162       EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_loaded_extension_id());
 163     }
 164   }
 165   EXPECT_EQ(9, mock_delegate_->load_call_count());
 166 }
 167
 168 TEST_F(ComponentExtensionIMEManagerTest, UnloadComponentExtensionIMETest) {
 169   for (size_t i = 0; i < ime_list_.size(); ++i) {
 170     for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) {
 171       const std::string input_method_id =
 172           TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 173               ime_list_[i].id,
 174               ime_list_[i].engines[j].engine_id);
 175       component_ext_mgr_->UnloadComponentExtensionIME(input_method_id);
 176       EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_unloaded_extension_id());
 177     }
 178   }
 179   EXPECT_EQ(9, mock_delegate_->unload_call_count());
 180 }
 181
 182 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedTest) {
 183   EXPECT_TRUE(component_ext_mgr_->IsWhitelisted(
 184       TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 185           ime_list_[0].id,
 186           ime_list_[0].engines[0].engine_id)));
 187   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 188       extension_ime_util::GetInputMethodID(
 189           ime_list_[0].id,
 190           ime_list_[0].engines[0].engine_id)));
 191   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted("mozc"));
 192   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 193       extension_ime_util::GetInputMethodID("AAAA", "012345")));
 194   EXPECT_FALSE(component_ext_mgr_->IsWhitelisted(
 195       TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 196           "AAAA", "012345")));
 197 }
 198
 199 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedExtensionTest) {
 200   EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[0].id));
 201   EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[1].id));
 202   EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("dummy"));
 203   EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension(""));
 204 }
 205
 206 TEST_F(ComponentExtensionIMEManagerTest, GetNameDescriptionTest) {
 207   for (size_t i = 0; i < ime_list_.size(); ++i) {
 208     for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) {
 209       const ComponentExtensionEngine& engine
 210           = ime_list_[i].engines[j];
 211
 212       const std::string input_method_id =
 213           TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 214               ime_list_[i].id,
 215               engine.engine_id);
 216
 217       EXPECT_EQ(input_method_id,
 218                 component_ext_mgr_->GetId(ime_list_[i].id, engine.engine_id));
 219       EXPECT_EQ(engine.display_name,
 220                 component_ext_mgr_->GetName(input_method_id));
 221       EXPECT_EQ(engine.description,
 222                 component_ext_mgr_->GetDescription(input_method_id));
 223     }
 224   }
 225 }
 226
 227 TEST_F(ComponentExtensionIMEManagerTest, ListIMEByLanguageTest) {
 228   const std::string hindi_layout1 =
 229       TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 230           ime_list_[1].id, ime_list_[1].engines[1].engine_id);
 231   const std::string hindi_layout2 =
 232       TestableComponentExtensionIMEManager::GetComponentExtensionIMEId(
 233           ime_list_[2].id, ime_list_[2].engines[0].engine_id);
 234
 235   std::vector<std::string> hindi_list
 236       = component_ext_mgr_->ListIMEByLanguage("hi");
 237   ASSERT_EQ(2UL, hindi_list.size());
 238   EXPECT_TRUE(hindi_list[0] == hindi_layout1 || hindi_list[0] == hindi_layout2);
 239   EXPECT_TRUE(hindi_list[1] == hindi_layout1 || hindi_list[1] == hindi_layout2);
 240
 241   EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("ru").size());
 242   EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("").size());
 243   EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("invalid").size());
 244   EXPECT_EQ(5UL, component_ext_mgr_->ListIMEByLanguage("en").size());
 245   EXPECT_EQ(2UL, component_ext_mgr_->ListIMEByLanguage("ja").size());
 246 }
 247
 248 TEST_F(ComponentExtensionIMEManagerTest, GetAllIMEAsInputMethodDescriptor) {
 249   input_method::InputMethodDescriptors descriptors =
 250       component_ext_mgr_->GetAllIMEAsInputMethodDescriptor();
 251   size_t total_ime_size = 0;
 252   for (size_t i = 0; i < ime_list_.size(); ++i) {
 253     total_ime_size += ime_list_[i].engines.size();
 254   }
 255   EXPECT_EQ(total_ime_size, descriptors.size());
 256 }
 257
 258 }  // namespace
 259
 260 }  // namespace input_method
 261 }  // namespace chromeos