OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 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 <iterator> |
| 6 #include <string> |
| 7 #include <vector> |
| 8 |
| 9 #include "base/callback.h" |
| 10 #include "base/macros.h" |
| 11 #include "base/memory/ref_counted.h" |
| 12 #include "base/message_loop/message_loop.h" |
| 13 #include "base/run_loop.h" |
| 14 #include "base/test/sequenced_worker_pool_owner.h" |
| 15 #include "base/version.h" |
| 16 #include "components/component_updater/component_updater_service.h" |
| 17 #include "components/component_updater/component_updater_service_internal.h" |
| 18 #include "components/component_updater/default_component_installer.h" |
| 19 #include "components/update_client/crx_update_item.h" |
| 20 #include "components/update_client/test_configurator.h" |
| 21 #include "components/update_client/update_client.h" |
| 22 #include "testing/gmock/include/gmock/gmock.h" |
| 23 #include "testing/gtest/include/gtest/gtest.h" |
| 24 |
| 25 using Configurator = update_client::Configurator; |
| 26 using CrxUpdateItem = update_client::CrxUpdateItem; |
| 27 using TestConfigurator = update_client::TestConfigurator; |
| 28 using UpdateClient = update_client::UpdateClient; |
| 29 |
| 30 using ::testing::_; |
| 31 using ::testing::Invoke; |
| 32 |
| 33 namespace component_updater { |
| 34 |
| 35 namespace { |
| 36 |
| 37 // This hash corresponds to jebgalgnebhfojomionfpkfelancnnkf.crx. |
| 38 const uint8_t kSha256Hash[] = {0x94, 0x16, 0x0b, 0x6d, 0x41, 0x75, 0xe9, 0xec, |
| 39 0x8e, 0xd5, 0xfa, 0x54, 0xb0, 0xd2, 0xdd, 0xa5, |
| 40 0x6e, 0x05, 0x6b, 0xe8, 0x73, 0x47, 0xf6, 0xc4, |
| 41 0x11, 0x9f, 0xbc, 0xb3, 0x09, 0xb3, 0x5b, 0x40}; |
| 42 |
| 43 class MockUpdateClient : public UpdateClient { |
| 44 public: |
| 45 MockUpdateClient() {}; |
| 46 MOCK_METHOD1(AddObserver, void(Observer* observer)); |
| 47 MOCK_METHOD1(RemoveObserver, void(Observer* observer)); |
| 48 MOCK_METHOD3(Install, |
| 49 void(const std::string& id, |
| 50 const CrxDataCallback& crx_data_callback, |
| 51 const CompletionCallback& completion_callback)); |
| 52 MOCK_METHOD3(Update, |
| 53 void(const std::vector<std::string>& ids, |
| 54 const CrxDataCallback& crx_data_callback, |
| 55 const CompletionCallback& completion_callback)); |
| 56 MOCK_CONST_METHOD2(GetCrxUpdateState, |
| 57 bool(const std::string& id, CrxUpdateItem* update_item)); |
| 58 MOCK_CONST_METHOD1(IsUpdating, bool(const std::string& id)); |
| 59 MOCK_METHOD0(Stop, void()); |
| 60 MOCK_METHOD3(SendUninstallPing, |
| 61 void(const std::string& id, const Version& version, int reason)); |
| 62 |
| 63 private: |
| 64 ~MockUpdateClient() override {}; |
| 65 }; |
| 66 |
| 67 class FakeInstallerTraits : public ComponentInstallerTraits { |
| 68 public: |
| 69 ~FakeInstallerTraits() override {} |
| 70 |
| 71 bool VerifyInstallation(const base::DictionaryValue& manifest, |
| 72 const base::FilePath& dir) const override { |
| 73 return true; |
| 74 } |
| 75 |
| 76 bool CanAutoUpdate() const override { return true; } |
| 77 |
| 78 bool RequiresNetworkEncryption() const override { return true; } |
| 79 |
| 80 bool OnCustomInstall(const base::DictionaryValue& manifest, |
| 81 const base::FilePath& install_dir) override { |
| 82 return true; |
| 83 } |
| 84 |
| 85 void ComponentReady( |
| 86 const base::Version& version, |
| 87 const base::FilePath& install_dir, |
| 88 std::unique_ptr<base::DictionaryValue> manifest) override {} |
| 89 |
| 90 base::FilePath GetRelativeInstallDir() const override { |
| 91 return base::FilePath(FILE_PATH_LITERAL("fake")); |
| 92 } |
| 93 |
| 94 void GetHash(std::vector<uint8_t>* hash) const override { GetPkHash(hash); } |
| 95 |
| 96 std::string GetName() const override { return "fake name"; } |
| 97 |
| 98 std::string GetAp() const override { return "fake-ap"; } |
| 99 |
| 100 private: |
| 101 static void GetPkHash(std::vector<uint8_t>* hash) { |
| 102 hash->assign(std::begin(kSha256Hash), std::end(kSha256Hash)); |
| 103 } |
| 104 }; |
| 105 |
| 106 class DefaultComponentInstallerTest : public testing::Test { |
| 107 public: |
| 108 DefaultComponentInstallerTest(); |
| 109 ~DefaultComponentInstallerTest() override; |
| 110 |
| 111 MockUpdateClient& update_client() { return *update_client_; } |
| 112 ComponentUpdateService* component_updater() { |
| 113 return component_updater_.get(); |
| 114 } |
| 115 scoped_refptr<TestConfigurator> configurator() const { return config_; } |
| 116 base::Closure quit_closure() const { return quit_closure_; } |
| 117 |
| 118 protected: |
| 119 void RunThreads(); |
| 120 |
| 121 private: |
| 122 static const int kNumWorkerThreads_ = 1; |
| 123 |
| 124 base::MessageLoopForUI message_loop_; |
| 125 base::RunLoop runloop_; |
| 126 base::Closure quit_closure_; |
| 127 |
| 128 std::unique_ptr<base::SequencedWorkerPoolOwner> worker_pool_; |
| 129 |
| 130 scoped_refptr<TestConfigurator> config_; |
| 131 scoped_refptr<MockUpdateClient> update_client_; |
| 132 std::unique_ptr<ComponentUpdateService> component_updater_; |
| 133 }; |
| 134 |
| 135 DefaultComponentInstallerTest::DefaultComponentInstallerTest() |
| 136 : worker_pool_( |
| 137 new base::SequencedWorkerPoolOwner(kNumWorkerThreads_, "test")) { |
| 138 quit_closure_ = runloop_.QuitClosure(); |
| 139 |
| 140 auto pool = worker_pool_->pool(); |
| 141 config_ = new TestConfigurator( |
| 142 pool->GetSequencedTaskRunner(pool->GetSequenceToken()), |
| 143 message_loop_.task_runner()); |
| 144 |
| 145 update_client_ = new MockUpdateClient(); |
| 146 EXPECT_CALL(update_client(), AddObserver(_)).Times(1); |
| 147 component_updater_.reset(new CrxUpdateService(config_, update_client_)); |
| 148 } |
| 149 |
| 150 DefaultComponentInstallerTest::~DefaultComponentInstallerTest() { |
| 151 EXPECT_CALL(update_client(), RemoveObserver(_)).Times(1); |
| 152 component_updater_.reset(); |
| 153 } |
| 154 |
| 155 void DefaultComponentInstallerTest::RunThreads() { |
| 156 runloop_.Run(); |
| 157 } |
| 158 |
| 159 } // namespace |
| 160 |
| 161 // Tests that the component metadata is propagated from the default |
| 162 // component installer and its component traits, through the instance of the |
| 163 // CrxComponent, to the component updater service. |
| 164 TEST_F(DefaultComponentInstallerTest, RegisterComponent) { |
| 165 class LoopHandler { |
| 166 public: |
| 167 LoopHandler(int max_cnt, const base::Closure& quit_closure) |
| 168 : max_cnt_(max_cnt), quit_closure_(quit_closure) {} |
| 169 |
| 170 void OnUpdate(const std::vector<std::string>& ids, |
| 171 const UpdateClient::CrxDataCallback& crx_data_callback, |
| 172 const UpdateClient::CompletionCallback& completion_callback) { |
| 173 completion_callback.Run(0); |
| 174 static int cnt = 0; |
| 175 ++cnt; |
| 176 if (cnt >= max_cnt_) |
| 177 quit_closure_.Run(); |
| 178 } |
| 179 |
| 180 private: |
| 181 const int max_cnt_; |
| 182 base::Closure quit_closure_; |
| 183 }; |
| 184 |
| 185 const std::string id("jebgalgnebhfojomionfpkfelancnnkf"); |
| 186 |
| 187 // Quit after one update check has been fired. |
| 188 LoopHandler loop_handler(1, quit_closure()); |
| 189 EXPECT_CALL(update_client(), Update(_, _, _)) |
| 190 .WillRepeatedly(Invoke(&loop_handler, &LoopHandler::OnUpdate)); |
| 191 |
| 192 EXPECT_CALL(update_client(), GetCrxUpdateState(id, _)).Times(1); |
| 193 EXPECT_CALL(update_client(), Stop()).Times(1); |
| 194 |
| 195 std::unique_ptr<ComponentInstallerTraits> traits(new FakeInstallerTraits()); |
| 196 |
| 197 DefaultComponentInstaller* installer = |
| 198 new DefaultComponentInstaller(std::move(traits)); |
| 199 installer->Register(component_updater(), base::Closure()); |
| 200 |
| 201 RunThreads(); |
| 202 |
| 203 CrxUpdateItem item; |
| 204 EXPECT_TRUE(component_updater()->GetComponentDetails(id, &item)); |
| 205 const CrxComponent& component(item.component); |
| 206 EXPECT_EQ( |
| 207 std::vector<uint8_t>(std::begin(kSha256Hash), std::end(kSha256Hash)), |
| 208 component.pk_hash); |
| 209 EXPECT_EQ(base::Version("0.0.0.0"), component.version); |
| 210 EXPECT_TRUE(component.fingerprint.empty()); |
| 211 EXPECT_STREQ("fake name", component.name.c_str()); |
| 212 EXPECT_STREQ("fake-ap", component.ap.c_str()); |
| 213 EXPECT_TRUE(component.requires_network_encryption); |
| 214 } |
| 215 |
| 216 } // namespace component_updater |
OLD | NEW |