| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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 "components/offline_pages/core/offline_page_metadata_store.h" | |
| 6 | |
| 7 #include <stdint.h> | |
| 8 | |
| 9 #include <memory> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/files/file_path.h" | |
| 13 #include "base/files/scoped_temp_dir.h" | |
| 14 #include "base/strings/string_number_conversions.h" | |
| 15 #include "base/strings/utf_string_conversions.h" | |
| 16 #include "base/test/test_simple_task_runner.h" | |
| 17 #include "base/threading/thread_task_runner_handle.h" | |
| 18 #include "components/offline_pages/core/offline_page_item.h" | |
| 19 #include "components/offline_pages/core/offline_page_metadata_store_sql.h" | |
| 20 #include "components/offline_pages/core/offline_page_model.h" | |
| 21 #include "sql/connection.h" | |
| 22 #include "sql/statement.h" | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 | |
| 25 namespace offline_pages { | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 #define OFFLINE_PAGES_TABLE_V1 "offlinepages_v1" | |
| 30 | |
| 31 const char kTestClientNamespace[] = "CLIENT_NAMESPACE"; | |
| 32 const char kTestURL[] = "https://example.com"; | |
| 33 const char kOriginalTestURL[] = "https://example.com/foo"; | |
| 34 const ClientId kTestClientId1(kTestClientNamespace, "1234"); | |
| 35 const ClientId kTestClientId2(kTestClientNamespace, "5678"); | |
| 36 const base::FilePath::CharType kFilePath[] = | |
| 37 FILE_PATH_LITERAL("/offline_pages/example_com.mhtml"); | |
| 38 int64_t kFileSize = 234567LL; | |
| 39 int64_t kOfflineId = 12345LL; | |
| 40 | |
| 41 // Build a store with outdated schema to simulate the upgrading process. | |
| 42 void BuildTestStoreWithSchemaFromM52(const base::FilePath& file) { | |
| 43 sql::Connection connection; | |
| 44 ASSERT_TRUE( | |
| 45 connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); | |
| 46 ASSERT_TRUE(connection.is_open()); | |
| 47 ASSERT_TRUE(connection.BeginTransaction()); | |
| 48 ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 | |
| 49 "(offline_id INTEGER PRIMARY KEY NOT NULL, " | |
| 50 "creation_time INTEGER NOT NULL, " | |
| 51 "file_size INTEGER NOT NULL, " | |
| 52 "version INTEGER NOT NULL, " | |
| 53 "last_access_time INTEGER NOT NULL, " | |
| 54 "access_count INTEGER NOT NULL, " | |
| 55 "status INTEGER NOT NULL DEFAULT 0, " | |
| 56 "user_initiated INTEGER, " | |
| 57 "client_namespace VARCHAR NOT NULL, " | |
| 58 "client_id VARCHAR NOT NULL, " | |
| 59 "online_url VARCHAR NOT NULL, " | |
| 60 "offline_url VARCHAR NOT NULL DEFAULT '', " | |
| 61 "file_path VARCHAR NOT NULL " | |
| 62 ")")); | |
| 63 ASSERT_TRUE(connection.CommitTransaction()); | |
| 64 sql::Statement statement(connection.GetUniqueStatement( | |
| 65 "INSERT INTO " OFFLINE_PAGES_TABLE_V1 | |
| 66 "(offline_id, creation_time, file_size, version, " | |
| 67 "last_access_time, access_count, client_namespace, " | |
| 68 "client_id, online_url, file_path) " | |
| 69 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); | |
| 70 statement.BindInt64(0, kOfflineId); | |
| 71 statement.BindInt(1, 0); | |
| 72 statement.BindInt64(2, kFileSize); | |
| 73 statement.BindInt(3, 0); | |
| 74 statement.BindInt(4, 0); | |
| 75 statement.BindInt(5, 1); | |
| 76 statement.BindCString(6, kTestClientNamespace); | |
| 77 statement.BindString(7, kTestClientId2.id); | |
| 78 statement.BindCString(8, kTestURL); | |
| 79 statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); | |
| 80 ASSERT_TRUE(statement.Run()); | |
| 81 ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); | |
| 82 ASSERT_FALSE( | |
| 83 connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "expiration_time")); | |
| 84 } | |
| 85 | |
| 86 void BuildTestStoreWithSchemaFromM53(const base::FilePath& file) { | |
| 87 sql::Connection connection; | |
| 88 ASSERT_TRUE( | |
| 89 connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); | |
| 90 ASSERT_TRUE(connection.is_open()); | |
| 91 ASSERT_TRUE(connection.BeginTransaction()); | |
| 92 ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 | |
| 93 "(offline_id INTEGER PRIMARY KEY NOT NULL, " | |
| 94 "creation_time INTEGER NOT NULL, " | |
| 95 "file_size INTEGER NOT NULL, " | |
| 96 "version INTEGER NOT NULL, " | |
| 97 "last_access_time INTEGER NOT NULL, " | |
| 98 "access_count INTEGER NOT NULL, " | |
| 99 "status INTEGER NOT NULL DEFAULT 0, " | |
| 100 "user_initiated INTEGER, " | |
| 101 "expiration_time INTEGER NOT NULL DEFAULT 0, " | |
| 102 "client_namespace VARCHAR NOT NULL, " | |
| 103 "client_id VARCHAR NOT NULL, " | |
| 104 "online_url VARCHAR NOT NULL, " | |
| 105 "offline_url VARCHAR NOT NULL DEFAULT '', " | |
| 106 "file_path VARCHAR NOT NULL " | |
| 107 ")")); | |
| 108 ASSERT_TRUE(connection.CommitTransaction()); | |
| 109 sql::Statement statement(connection.GetUniqueStatement( | |
| 110 "INSERT INTO " OFFLINE_PAGES_TABLE_V1 | |
| 111 "(offline_id, creation_time, file_size, version, " | |
| 112 "last_access_time, access_count, client_namespace, " | |
| 113 "client_id, online_url, file_path, expiration_time) " | |
| 114 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); | |
| 115 statement.BindInt64(0, kOfflineId); | |
| 116 statement.BindInt(1, 0); | |
| 117 statement.BindInt64(2, kFileSize); | |
| 118 statement.BindInt(3, 0); | |
| 119 statement.BindInt(4, 0); | |
| 120 statement.BindInt(5, 1); | |
| 121 statement.BindCString(6, kTestClientNamespace); | |
| 122 statement.BindString(7, kTestClientId2.id); | |
| 123 statement.BindCString(8, kTestURL); | |
| 124 statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); | |
| 125 statement.BindInt64(10, base::Time::Now().ToInternalValue()); | |
| 126 ASSERT_TRUE(statement.Run()); | |
| 127 ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); | |
| 128 ASSERT_FALSE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "title")); | |
| 129 } | |
| 130 | |
| 131 void BuildTestStoreWithSchemaFromM54(const base::FilePath& file) { | |
| 132 sql::Connection connection; | |
| 133 ASSERT_TRUE( | |
| 134 connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); | |
| 135 ASSERT_TRUE(connection.is_open()); | |
| 136 ASSERT_TRUE(connection.BeginTransaction()); | |
| 137 ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 | |
| 138 "(offline_id INTEGER PRIMARY KEY NOT NULL, " | |
| 139 "creation_time INTEGER NOT NULL, " | |
| 140 "file_size INTEGER NOT NULL, " | |
| 141 "version INTEGER NOT NULL, " | |
| 142 "last_access_time INTEGER NOT NULL, " | |
| 143 "access_count INTEGER NOT NULL, " | |
| 144 "status INTEGER NOT NULL DEFAULT 0, " | |
| 145 "user_initiated INTEGER, " | |
| 146 "expiration_time INTEGER NOT NULL DEFAULT 0, " | |
| 147 "client_namespace VARCHAR NOT NULL, " | |
| 148 "client_id VARCHAR NOT NULL, " | |
| 149 "online_url VARCHAR NOT NULL, " | |
| 150 "offline_url VARCHAR NOT NULL DEFAULT '', " | |
| 151 "file_path VARCHAR NOT NULL, " | |
| 152 "title VARCHAR NOT NULL DEFAULT ''" | |
| 153 ")")); | |
| 154 ASSERT_TRUE(connection.CommitTransaction()); | |
| 155 sql::Statement statement(connection.GetUniqueStatement( | |
| 156 "INSERT INTO " OFFLINE_PAGES_TABLE_V1 | |
| 157 "(offline_id, creation_time, file_size, version, " | |
| 158 "last_access_time, access_count, client_namespace, " | |
| 159 "client_id, online_url, file_path, expiration_time, title) " | |
| 160 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); | |
| 161 statement.BindInt64(0, kOfflineId); | |
| 162 statement.BindInt(1, 0); | |
| 163 statement.BindInt64(2, kFileSize); | |
| 164 statement.BindInt(3, 0); | |
| 165 statement.BindInt(4, 0); | |
| 166 statement.BindInt(5, 1); | |
| 167 statement.BindCString(6, kTestClientNamespace); | |
| 168 statement.BindString(7, kTestClientId2.id); | |
| 169 statement.BindCString(8, kTestURL); | |
| 170 statement.BindString(9, base::FilePath(kFilePath).MaybeAsASCII()); | |
| 171 statement.BindInt64(10, base::Time::Now().ToInternalValue()); | |
| 172 statement.BindString16(11, base::UTF8ToUTF16("Test title")); | |
| 173 ASSERT_TRUE(statement.Run()); | |
| 174 ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); | |
| 175 ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "version")); | |
| 176 ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "status")); | |
| 177 ASSERT_TRUE( | |
| 178 connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "user_initiated")); | |
| 179 ASSERT_TRUE( | |
| 180 connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "offline_url")); | |
| 181 } | |
| 182 | |
| 183 void BuildTestStoreWithSchemaFromM55(const base::FilePath& file) { | |
| 184 sql::Connection connection; | |
| 185 ASSERT_TRUE( | |
| 186 connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); | |
| 187 ASSERT_TRUE(connection.is_open()); | |
| 188 ASSERT_TRUE(connection.BeginTransaction()); | |
| 189 ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 | |
| 190 "(offline_id INTEGER PRIMARY KEY NOT NULL, " | |
| 191 "creation_time INTEGER NOT NULL, " | |
| 192 "file_size INTEGER NOT NULL, " | |
| 193 "last_access_time INTEGER NOT NULL, " | |
| 194 "access_count INTEGER NOT NULL, " | |
| 195 "expiration_time INTEGER NOT NULL DEFAULT 0, " | |
| 196 "client_namespace VARCHAR NOT NULL, " | |
| 197 "client_id VARCHAR NOT NULL, " | |
| 198 "online_url VARCHAR NOT NULL, " | |
| 199 "file_path VARCHAR NOT NULL, " | |
| 200 "title VARCHAR NOT NULL DEFAULT ''" | |
| 201 ")")); | |
| 202 ASSERT_TRUE(connection.CommitTransaction()); | |
| 203 sql::Statement statement(connection.GetUniqueStatement( | |
| 204 "INSERT INTO " OFFLINE_PAGES_TABLE_V1 | |
| 205 "(offline_id, creation_time, file_size, " | |
| 206 "last_access_time, access_count, client_namespace, " | |
| 207 "client_id, online_url, file_path, expiration_time, title) " | |
| 208 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); | |
| 209 statement.BindInt64(0, kOfflineId); | |
| 210 statement.BindInt(1, 0); | |
| 211 statement.BindInt64(2, kFileSize); | |
| 212 statement.BindInt(3, 0); | |
| 213 statement.BindInt(4, 1); | |
| 214 statement.BindCString(5, kTestClientNamespace); | |
| 215 statement.BindString(6, kTestClientId2.id); | |
| 216 statement.BindCString(7, kTestURL); | |
| 217 statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); | |
| 218 statement.BindInt64(9, base::Time::Now().ToInternalValue()); | |
| 219 statement.BindString16(10, base::UTF8ToUTF16("Test title")); | |
| 220 ASSERT_TRUE(statement.Run()); | |
| 221 ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); | |
| 222 ASSERT_TRUE(connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "title")); | |
| 223 ASSERT_FALSE( | |
| 224 connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "original_url")); | |
| 225 } | |
| 226 | |
| 227 void BuildTestStoreWithSchemaFromM56(const base::FilePath& file) { | |
| 228 sql::Connection connection; | |
| 229 ASSERT_TRUE( | |
| 230 connection.Open(file.Append(FILE_PATH_LITERAL("OfflinePages.db")))); | |
| 231 ASSERT_TRUE(connection.is_open()); | |
| 232 ASSERT_TRUE(connection.BeginTransaction()); | |
| 233 ASSERT_TRUE(connection.Execute("CREATE TABLE " OFFLINE_PAGES_TABLE_V1 | |
| 234 "(offline_id INTEGER PRIMARY KEY NOT NULL, " | |
| 235 "creation_time INTEGER NOT NULL, " | |
| 236 "file_size INTEGER NOT NULL, " | |
| 237 "last_access_time INTEGER NOT NULL, " | |
| 238 "access_count INTEGER NOT NULL, " | |
| 239 "expiration_time INTEGER NOT NULL DEFAULT 0, " | |
| 240 "client_namespace VARCHAR NOT NULL, " | |
| 241 "client_id VARCHAR NOT NULL, " | |
| 242 "online_url VARCHAR NOT NULL, " | |
| 243 "file_path VARCHAR NOT NULL, " | |
| 244 "title VARCHAR NOT NULL DEFAULT '', " | |
| 245 "original_url VARCHAR NOT NULL DEFAULT ''" | |
| 246 ")")); | |
| 247 ASSERT_TRUE(connection.CommitTransaction()); | |
| 248 sql::Statement statement(connection.GetUniqueStatement( | |
| 249 "INSERT INTO " OFFLINE_PAGES_TABLE_V1 | |
| 250 "(offline_id, creation_time, file_size, " | |
| 251 "last_access_time, access_count, client_namespace, " | |
| 252 "client_id, online_url, file_path, expiration_time, title, original_url) " | |
| 253 "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")); | |
| 254 statement.BindInt64(0, kOfflineId); | |
| 255 statement.BindInt(1, 0); | |
| 256 statement.BindInt64(2, kFileSize); | |
| 257 statement.BindInt(3, 0); | |
| 258 statement.BindInt(4, 1); | |
| 259 statement.BindCString(5, kTestClientNamespace); | |
| 260 statement.BindString(6, kTestClientId2.id); | |
| 261 statement.BindCString(7, kTestURL); | |
| 262 statement.BindString(8, base::FilePath(kFilePath).MaybeAsASCII()); | |
| 263 statement.BindInt64(9, base::Time::Now().ToInternalValue()); | |
| 264 statement.BindString16(10, base::UTF8ToUTF16("Test title")); | |
| 265 statement.BindCString(11, kOriginalTestURL); | |
| 266 ASSERT_TRUE(statement.Run()); | |
| 267 ASSERT_TRUE(connection.DoesTableExist(OFFLINE_PAGES_TABLE_V1)); | |
| 268 ASSERT_TRUE( | |
| 269 connection.DoesColumnExist(OFFLINE_PAGES_TABLE_V1, "expiration_time")); | |
| 270 } | |
| 271 | |
| 272 class OfflinePageMetadataStoreFactory { | |
| 273 public: | |
| 274 OfflinePageMetadataStore* BuildStore(const base::FilePath& file_path) { | |
| 275 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 276 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 277 return store; | |
| 278 } | |
| 279 | |
| 280 OfflinePageMetadataStore* BuildStoreM52(const base::FilePath& file_path) { | |
| 281 BuildTestStoreWithSchemaFromM52(file_path); | |
| 282 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 283 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 284 return store; | |
| 285 } | |
| 286 | |
| 287 OfflinePageMetadataStore* BuildStoreM53(const base::FilePath& file_path) { | |
| 288 BuildTestStoreWithSchemaFromM53(file_path); | |
| 289 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 290 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 291 return store; | |
| 292 } | |
| 293 | |
| 294 OfflinePageMetadataStore* BuildStoreM54(const base::FilePath& file_path) { | |
| 295 BuildTestStoreWithSchemaFromM54(file_path); | |
| 296 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 297 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 298 return store; | |
| 299 } | |
| 300 | |
| 301 OfflinePageMetadataStore* BuildStoreM55(const base::FilePath& file_path) { | |
| 302 BuildTestStoreWithSchemaFromM55(file_path); | |
| 303 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 304 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 305 return store; | |
| 306 } | |
| 307 | |
| 308 OfflinePageMetadataStore* BuildStoreM56(const base::FilePath& file_path) { | |
| 309 BuildTestStoreWithSchemaFromM56(file_path); | |
| 310 OfflinePageMetadataStoreSQL* store = new OfflinePageMetadataStoreSQL( | |
| 311 base::ThreadTaskRunnerHandle::Get(), file_path); | |
| 312 return store; | |
| 313 } | |
| 314 }; | |
| 315 | |
| 316 enum CalledCallback { NONE, LOAD, ADD, UPDATE, REMOVE, RESET }; | |
| 317 enum Status { STATUS_NONE, STATUS_TRUE, STATUS_FALSE }; | |
| 318 | |
| 319 class OfflinePageMetadataStoreTest : public testing::Test { | |
| 320 public: | |
| 321 OfflinePageMetadataStoreTest(); | |
| 322 ~OfflinePageMetadataStoreTest() override; | |
| 323 | |
| 324 void TearDown() override { | |
| 325 // Wait for all the pieces of the store to delete itself properly. | |
| 326 PumpLoop(); | |
| 327 } | |
| 328 | |
| 329 std::unique_ptr<OfflinePageMetadataStore> BuildStore(); | |
| 330 std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM52(); | |
| 331 std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM53(); | |
| 332 std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM54(); | |
| 333 std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM55(); | |
| 334 std::unique_ptr<OfflinePageMetadataStore> BuildStoreWithSchemaFromM56(); | |
| 335 | |
| 336 void PumpLoop(); | |
| 337 | |
| 338 void InitializeCallback(bool success); | |
| 339 void GetOfflinePagesCallback( | |
| 340 const std::vector<OfflinePageItem>& offline_pages); | |
| 341 void AddCallback(ItemActionStatus status); | |
| 342 void UpdateCallback(CalledCallback called_callback, | |
| 343 std::unique_ptr<OfflinePagesUpdateResult> result); | |
| 344 void ResetCallback(bool success); | |
| 345 | |
| 346 void ClearResults(); | |
| 347 | |
| 348 OfflinePageItem CheckThatStoreHasOneItem(); | |
| 349 void CheckThatOfflinePageCanBeSaved( | |
| 350 std::unique_ptr<OfflinePageMetadataStore> store); | |
| 351 | |
| 352 OfflinePagesUpdateResult* last_update_result() { | |
| 353 return last_update_result_.get(); | |
| 354 } | |
| 355 | |
| 356 protected: | |
| 357 CalledCallback last_called_callback_; | |
| 358 Status last_status_; | |
| 359 std::unique_ptr<OfflinePagesUpdateResult> last_update_result_; | |
| 360 std::vector<OfflinePageItem> offline_pages_; | |
| 361 OfflinePageMetadataStoreFactory factory_; | |
| 362 | |
| 363 base::ScopedTempDir temp_directory_; | |
| 364 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| 365 base::ThreadTaskRunnerHandle task_runner_handle_; | |
| 366 }; | |
| 367 | |
| 368 OfflinePageMetadataStoreTest::OfflinePageMetadataStoreTest() | |
| 369 : last_called_callback_(NONE), | |
| 370 last_status_(STATUS_NONE), | |
| 371 task_runner_(new base::TestSimpleTaskRunner), | |
| 372 task_runner_handle_(task_runner_) { | |
| 373 EXPECT_TRUE(temp_directory_.CreateUniqueTempDir()); | |
| 374 } | |
| 375 | |
| 376 OfflinePageMetadataStoreTest::~OfflinePageMetadataStoreTest() {} | |
| 377 | |
| 378 void OfflinePageMetadataStoreTest::PumpLoop() { | |
| 379 task_runner_->RunUntilIdle(); | |
| 380 } | |
| 381 | |
| 382 void OfflinePageMetadataStoreTest::InitializeCallback(bool success) { | |
| 383 last_status_ = success ? STATUS_TRUE : STATUS_FALSE; | |
| 384 } | |
| 385 | |
| 386 void OfflinePageMetadataStoreTest::GetOfflinePagesCallback( | |
| 387 const std::vector<OfflinePageItem>& offline_pages) { | |
| 388 last_called_callback_ = LOAD; | |
| 389 offline_pages_.swap(const_cast<std::vector<OfflinePageItem>&>(offline_pages)); | |
| 390 } | |
| 391 | |
| 392 void OfflinePageMetadataStoreTest::AddCallback(ItemActionStatus status) { | |
| 393 last_called_callback_ = ADD; | |
| 394 last_status_ = | |
| 395 status == ItemActionStatus::SUCCESS ? STATUS_TRUE : STATUS_FALSE; | |
| 396 } | |
| 397 | |
| 398 void OfflinePageMetadataStoreTest::UpdateCallback( | |
| 399 CalledCallback called_callback, | |
| 400 std::unique_ptr<OfflinePagesUpdateResult> result) { | |
| 401 last_called_callback_ = called_callback; | |
| 402 last_status_ = result->updated_items.size() > 0 ? STATUS_TRUE : STATUS_FALSE; | |
| 403 last_update_result_ = std::move(result); | |
| 404 } | |
| 405 | |
| 406 void OfflinePageMetadataStoreTest::ResetCallback(bool success) { | |
| 407 last_called_callback_ = RESET; | |
| 408 last_status_ = success ? STATUS_TRUE : STATUS_FALSE; | |
| 409 } | |
| 410 | |
| 411 void OfflinePageMetadataStoreTest::ClearResults() { | |
| 412 last_called_callback_ = NONE; | |
| 413 last_status_ = STATUS_NONE; | |
| 414 offline_pages_.clear(); | |
| 415 last_update_result_.reset(nullptr); | |
| 416 } | |
| 417 | |
| 418 OfflinePageItem OfflinePageMetadataStoreTest::CheckThatStoreHasOneItem() { | |
| 419 EXPECT_EQ(LOAD, last_called_callback_); | |
| 420 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 421 EXPECT_EQ(1U, offline_pages_.size()); | |
| 422 | |
| 423 return offline_pages_[0]; | |
| 424 } | |
| 425 | |
| 426 void OfflinePageMetadataStoreTest::CheckThatOfflinePageCanBeSaved( | |
| 427 std::unique_ptr<OfflinePageMetadataStore> store) { | |
| 428 size_t store_size = offline_pages_.size(); | |
| 429 OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, | |
| 430 base::FilePath(kFilePath), kFileSize); | |
| 431 offline_page.title = base::UTF8ToUTF16("a title"); | |
| 432 offline_page.original_url = GURL(kOriginalTestURL); | |
| 433 | |
| 434 store->AddOfflinePage(offline_page, | |
| 435 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 436 base::Unretained(this))); | |
| 437 PumpLoop(); | |
| 438 EXPECT_EQ(ADD, last_called_callback_); | |
| 439 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 440 ClearResults(); | |
| 441 | |
| 442 // Close the store first to ensure file lock is removed. | |
| 443 store.reset(); | |
| 444 store = BuildStore(); | |
| 445 PumpLoop(); | |
| 446 | |
| 447 EXPECT_EQ(LOAD, last_called_callback_); | |
| 448 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 449 ASSERT_EQ(store_size + 1, offline_pages_.size()); | |
| 450 if (store_size > 0 && | |
| 451 offline_pages_[0].offline_id != offline_page.offline_id) { | |
| 452 std::swap(offline_pages_[0], offline_pages_[1]); | |
| 453 } | |
| 454 EXPECT_EQ(offline_page, offline_pages_[0]); | |
| 455 } | |
| 456 | |
| 457 std::unique_ptr<OfflinePageMetadataStore> | |
| 458 OfflinePageMetadataStoreTest::BuildStore() { | |
| 459 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 460 factory_.BuildStore(temp_directory_.GetPath())); | |
| 461 PumpLoop(); | |
| 462 store->Initialize( | |
| 463 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 464 base::Unretained(this))); | |
| 465 PumpLoop(); | |
| 466 store->GetOfflinePages( | |
| 467 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 468 base::Unretained(this))); | |
| 469 PumpLoop(); | |
| 470 return store; | |
| 471 } | |
| 472 | |
| 473 std::unique_ptr<OfflinePageMetadataStore> | |
| 474 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM52() { | |
| 475 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 476 factory_.BuildStoreM52(temp_directory_.GetPath())); | |
| 477 PumpLoop(); | |
| 478 store->Initialize( | |
| 479 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 480 base::Unretained(this))); | |
| 481 PumpLoop(); | |
| 482 store->GetOfflinePages( | |
| 483 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 484 base::Unretained(this))); | |
| 485 PumpLoop(); | |
| 486 return store; | |
| 487 } | |
| 488 | |
| 489 std::unique_ptr<OfflinePageMetadataStore> | |
| 490 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM53() { | |
| 491 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 492 factory_.BuildStoreM53(temp_directory_.GetPath())); | |
| 493 PumpLoop(); | |
| 494 store->Initialize( | |
| 495 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 496 base::Unretained(this))); | |
| 497 PumpLoop(); | |
| 498 store->GetOfflinePages( | |
| 499 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 500 base::Unretained(this))); | |
| 501 PumpLoop(); | |
| 502 return store; | |
| 503 } | |
| 504 | |
| 505 std::unique_ptr<OfflinePageMetadataStore> | |
| 506 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM54() { | |
| 507 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 508 factory_.BuildStoreM54(temp_directory_.GetPath())); | |
| 509 PumpLoop(); | |
| 510 store->Initialize( | |
| 511 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 512 base::Unretained(this))); | |
| 513 PumpLoop(); | |
| 514 store->GetOfflinePages( | |
| 515 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 516 base::Unretained(this))); | |
| 517 PumpLoop(); | |
| 518 return store; | |
| 519 } | |
| 520 | |
| 521 std::unique_ptr<OfflinePageMetadataStore> | |
| 522 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM55() { | |
| 523 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 524 factory_.BuildStoreM55(temp_directory_.GetPath())); | |
| 525 PumpLoop(); | |
| 526 store->Initialize( | |
| 527 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 528 base::Unretained(this))); | |
| 529 PumpLoop(); | |
| 530 store->GetOfflinePages( | |
| 531 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 532 base::Unretained(this))); | |
| 533 PumpLoop(); | |
| 534 return store; | |
| 535 } | |
| 536 | |
| 537 std::unique_ptr<OfflinePageMetadataStore> | |
| 538 OfflinePageMetadataStoreTest::BuildStoreWithSchemaFromM56() { | |
| 539 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 540 factory_.BuildStoreM56(temp_directory_.GetPath())); | |
| 541 PumpLoop(); | |
| 542 store->Initialize( | |
| 543 base::Bind(&OfflinePageMetadataStoreTest::InitializeCallback, | |
| 544 base::Unretained(this))); | |
| 545 PumpLoop(); | |
| 546 store->GetOfflinePages( | |
| 547 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 548 base::Unretained(this))); | |
| 549 PumpLoop(); | |
| 550 return store; | |
| 551 } | |
| 552 | |
| 553 // Loads empty store and makes sure that there are no offline pages stored in | |
| 554 // it. | |
| 555 TEST_F(OfflinePageMetadataStoreTest, LoadEmptyStore) { | |
| 556 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 557 EXPECT_EQ(LOAD, last_called_callback_); | |
| 558 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 559 EXPECT_EQ(0U, offline_pages_.size()); | |
| 560 } | |
| 561 | |
| 562 TEST_F(OfflinePageMetadataStoreTest, GetOfflinePagesFromInvalidStore) { | |
| 563 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 564 OfflinePageMetadataStoreSQL* sql_store = | |
| 565 static_cast<OfflinePageMetadataStoreSQL*>(store.get()); | |
| 566 | |
| 567 sql_store->SetStateForTesting(StoreState::NOT_LOADED, false); | |
| 568 store->GetOfflinePages( | |
| 569 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 570 base::Unretained(this))); | |
| 571 PumpLoop(); | |
| 572 EXPECT_EQ(LOAD, last_called_callback_); | |
| 573 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 574 EXPECT_EQ(StoreState::NOT_LOADED, store->state()); | |
| 575 | |
| 576 ClearResults(); | |
| 577 sql_store->SetStateForTesting(StoreState::FAILED_LOADING, false); | |
| 578 store->GetOfflinePages( | |
| 579 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 580 base::Unretained(this))); | |
| 581 PumpLoop(); | |
| 582 EXPECT_EQ(LOAD, last_called_callback_); | |
| 583 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 584 EXPECT_EQ(StoreState::FAILED_LOADING, store->state()); | |
| 585 | |
| 586 ClearResults(); | |
| 587 sql_store->SetStateForTesting(StoreState::FAILED_RESET, false); | |
| 588 store->GetOfflinePages( | |
| 589 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 590 base::Unretained(this))); | |
| 591 PumpLoop(); | |
| 592 EXPECT_EQ(LOAD, last_called_callback_); | |
| 593 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 594 EXPECT_EQ(StoreState::FAILED_RESET, store->state()); | |
| 595 | |
| 596 ClearResults(); | |
| 597 sql_store->SetStateForTesting(StoreState::LOADED, true); | |
| 598 store->GetOfflinePages( | |
| 599 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 600 base::Unretained(this))); | |
| 601 PumpLoop(); | |
| 602 EXPECT_EQ(LOAD, last_called_callback_); | |
| 603 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 604 | |
| 605 ClearResults(); | |
| 606 sql_store->SetStateForTesting(StoreState::NOT_LOADED, true); | |
| 607 store->GetOfflinePages( | |
| 608 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 609 base::Unretained(this))); | |
| 610 PumpLoop(); | |
| 611 EXPECT_EQ(LOAD, last_called_callback_); | |
| 612 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 613 | |
| 614 ClearResults(); | |
| 615 sql_store->SetStateForTesting(StoreState::FAILED_LOADING, false); | |
| 616 store->GetOfflinePages( | |
| 617 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 618 base::Unretained(this))); | |
| 619 PumpLoop(); | |
| 620 EXPECT_EQ(LOAD, last_called_callback_); | |
| 621 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 622 | |
| 623 ClearResults(); | |
| 624 sql_store->SetStateForTesting(StoreState::FAILED_RESET, false); | |
| 625 store->GetOfflinePages( | |
| 626 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 627 base::Unretained(this))); | |
| 628 PumpLoop(); | |
| 629 EXPECT_EQ(LOAD, last_called_callback_); | |
| 630 EXPECT_EQ(0UL, offline_pages_.size()); | |
| 631 } | |
| 632 | |
| 633 // Loads a store which has an outdated schema. | |
| 634 // This test case would crash if it's not handling correctly when we're loading | |
| 635 // old version stores. | |
| 636 TEST_F(OfflinePageMetadataStoreTest, LoadVersion52Store) { | |
| 637 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 638 BuildStoreWithSchemaFromM52()); | |
| 639 | |
| 640 OfflinePageItem item = CheckThatStoreHasOneItem(); | |
| 641 CheckThatOfflinePageCanBeSaved(std::move(store)); | |
| 642 } | |
| 643 | |
| 644 // Loads a store which has an outdated schema. | |
| 645 // This test case would crash if it's not handling correctly when we're loading | |
| 646 // old version stores. | |
| 647 TEST_F(OfflinePageMetadataStoreTest, LoadVersion53Store) { | |
| 648 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 649 BuildStoreWithSchemaFromM53()); | |
| 650 | |
| 651 OfflinePageItem item = CheckThatStoreHasOneItem(); | |
| 652 CheckThatOfflinePageCanBeSaved(std::move(store)); | |
| 653 } | |
| 654 | |
| 655 // Loads a string with schema from M54. | |
| 656 // This test case would crash if it's not handling correctly when we're loading | |
| 657 // old version stores. | |
| 658 TEST_F(OfflinePageMetadataStoreTest, LoadVersion54Store) { | |
| 659 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 660 BuildStoreWithSchemaFromM54()); | |
| 661 | |
| 662 OfflinePageItem item = CheckThatStoreHasOneItem(); | |
| 663 CheckThatOfflinePageCanBeSaved(std::move(store)); | |
| 664 } | |
| 665 | |
| 666 // Loads a string with schema from M55. | |
| 667 // This test case would crash if it's not handling correctly when we're loading | |
| 668 // old version stores. | |
| 669 TEST_F(OfflinePageMetadataStoreTest, LoadVersion55Store) { | |
| 670 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 671 BuildStoreWithSchemaFromM55()); | |
| 672 | |
| 673 OfflinePageItem item = CheckThatStoreHasOneItem(); | |
| 674 CheckThatOfflinePageCanBeSaved(std::move(store)); | |
| 675 } | |
| 676 | |
| 677 // Loads a string with schema from M56. | |
| 678 // This test case would crash if it's not handling correctly when we're loading | |
| 679 // old version stores. | |
| 680 TEST_F(OfflinePageMetadataStoreTest, LoadVersion56Store) { | |
| 681 std::unique_ptr<OfflinePageMetadataStore> store( | |
| 682 BuildStoreWithSchemaFromM56()); | |
| 683 | |
| 684 OfflinePageItem item = CheckThatStoreHasOneItem(); | |
| 685 CheckThatOfflinePageCanBeSaved(std::move(store)); | |
| 686 } | |
| 687 | |
| 688 // Adds metadata of an offline page into a store and then opens the store | |
| 689 // again to make sure that stored metadata survives store restarts. | |
| 690 TEST_F(OfflinePageMetadataStoreTest, AddOfflinePage) { | |
| 691 CheckThatOfflinePageCanBeSaved(BuildStore()); | |
| 692 } | |
| 693 | |
| 694 TEST_F(OfflinePageMetadataStoreTest, AddSameOfflinePageTwice) { | |
| 695 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 696 | |
| 697 OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, | |
| 698 base::FilePath(kFilePath), kFileSize); | |
| 699 offline_page.title = base::UTF8ToUTF16("a title"); | |
| 700 | |
| 701 store->AddOfflinePage(offline_page, | |
| 702 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 703 base::Unretained(this))); | |
| 704 PumpLoop(); | |
| 705 EXPECT_EQ(ADD, last_called_callback_); | |
| 706 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 707 ClearResults(); | |
| 708 | |
| 709 store->AddOfflinePage(offline_page, | |
| 710 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 711 base::Unretained(this))); | |
| 712 PumpLoop(); | |
| 713 EXPECT_EQ(ADD, last_called_callback_); | |
| 714 EXPECT_EQ(STATUS_FALSE, last_status_); | |
| 715 } | |
| 716 | |
| 717 // Tests removing offline page metadata from the store, for which it first adds | |
| 718 // metadata of an offline page. | |
| 719 TEST_F(OfflinePageMetadataStoreTest, RemoveOfflinePage) { | |
| 720 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 721 | |
| 722 // Add an offline page. | |
| 723 OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, | |
| 724 base::FilePath(kFilePath), kFileSize); | |
| 725 store->AddOfflinePage(offline_page, | |
| 726 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 727 base::Unretained(this))); | |
| 728 PumpLoop(); | |
| 729 EXPECT_EQ(ADD, last_called_callback_); | |
| 730 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 731 | |
| 732 ClearResults(); | |
| 733 | |
| 734 // Get all pages from the store. | |
| 735 store->GetOfflinePages( | |
| 736 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 737 base::Unretained(this))); | |
| 738 PumpLoop(); | |
| 739 EXPECT_EQ(LOAD, last_called_callback_); | |
| 740 EXPECT_EQ(1U, offline_pages_.size()); | |
| 741 | |
| 742 // Remove the offline page. | |
| 743 std::vector<int64_t> ids_to_remove; | |
| 744 ids_to_remove.push_back(offline_page.offline_id); | |
| 745 store->RemoveOfflinePages( | |
| 746 ids_to_remove, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback, | |
| 747 base::Unretained(this), REMOVE)); | |
| 748 PumpLoop(); | |
| 749 EXPECT_EQ(REMOVE, last_called_callback_); | |
| 750 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 751 ASSERT_TRUE(last_update_result() != nullptr); | |
| 752 EXPECT_EQ(1UL, last_update_result()->item_statuses.size()); | |
| 753 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
| 754 last_update_result()->item_statuses.begin()->second); | |
| 755 EXPECT_EQ(1UL, last_update_result()->updated_items.size()); | |
| 756 EXPECT_EQ(offline_page, *(last_update_result()->updated_items.begin())); | |
| 757 | |
| 758 ClearResults(); | |
| 759 | |
| 760 // Get all pages from the store. | |
| 761 store->GetOfflinePages( | |
| 762 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 763 base::Unretained(this))); | |
| 764 PumpLoop(); | |
| 765 EXPECT_EQ(LOAD, last_called_callback_); | |
| 766 EXPECT_EQ(0U, offline_pages_.size()); | |
| 767 | |
| 768 ClearResults(); | |
| 769 | |
| 770 // Close and reload the store. | |
| 771 store.reset(); | |
| 772 store = BuildStore(); | |
| 773 EXPECT_EQ(LOAD, last_called_callback_); | |
| 774 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 775 EXPECT_EQ(0U, offline_pages_.size()); | |
| 776 } | |
| 777 | |
| 778 // Adds metadata of multiple offline pages into a store and removes some. | |
| 779 TEST_F(OfflinePageMetadataStoreTest, AddRemoveMultipleOfflinePages) { | |
| 780 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 781 | |
| 782 // Add an offline page. | |
| 783 OfflinePageItem offline_page_1(GURL(kTestURL), 12345LL, kTestClientId1, | |
| 784 base::FilePath(kFilePath), kFileSize); | |
| 785 store->AddOfflinePage(offline_page_1, | |
| 786 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 787 base::Unretained(this))); | |
| 788 PumpLoop(); | |
| 789 EXPECT_EQ(ADD, last_called_callback_); | |
| 790 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 791 | |
| 792 ClearResults(); | |
| 793 | |
| 794 // Add anther offline page. | |
| 795 base::FilePath file_path_2 = | |
| 796 base::FilePath(FILE_PATH_LITERAL("//other.page.com.mhtml")); | |
| 797 OfflinePageItem offline_page_2(GURL("https://other.page.com"), 5678LL, | |
| 798 kTestClientId2, file_path_2, 12345, | |
| 799 base::Time::Now()); | |
| 800 offline_page_2.original_url = GURL("https://example.com/bar"); | |
| 801 store->AddOfflinePage(offline_page_2, | |
| 802 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 803 base::Unretained(this))); | |
| 804 PumpLoop(); | |
| 805 EXPECT_EQ(ADD, last_called_callback_); | |
| 806 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 807 | |
| 808 ClearResults(); | |
| 809 | |
| 810 // Get all pages from the store. | |
| 811 store->GetOfflinePages( | |
| 812 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 813 base::Unretained(this))); | |
| 814 PumpLoop(); | |
| 815 | |
| 816 EXPECT_EQ(LOAD, last_called_callback_); | |
| 817 EXPECT_EQ(2U, offline_pages_.size()); | |
| 818 | |
| 819 // Remove the offline page. | |
| 820 std::vector<int64_t> ids_to_remove; | |
| 821 ids_to_remove.push_back(offline_page_1.offline_id); | |
| 822 store->RemoveOfflinePages( | |
| 823 ids_to_remove, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback, | |
| 824 base::Unretained(this), REMOVE)); | |
| 825 PumpLoop(); | |
| 826 EXPECT_EQ(REMOVE, last_called_callback_); | |
| 827 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 828 ASSERT_TRUE(last_update_result() != nullptr); | |
| 829 EXPECT_EQ(1UL, last_update_result()->item_statuses.size()); | |
| 830 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
| 831 last_update_result()->item_statuses.begin()->second); | |
| 832 EXPECT_EQ(1UL, last_update_result()->updated_items.size()); | |
| 833 EXPECT_EQ(offline_page_1, *(last_update_result()->updated_items.begin())); | |
| 834 | |
| 835 ClearResults(); | |
| 836 | |
| 837 // Close and reload the store. | |
| 838 store.reset(); | |
| 839 store = BuildStore(); | |
| 840 store->GetOfflinePages( | |
| 841 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 842 base::Unretained(this))); | |
| 843 PumpLoop(); | |
| 844 | |
| 845 EXPECT_EQ(LOAD, last_called_callback_); | |
| 846 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 847 ASSERT_EQ(1U, offline_pages_.size()); | |
| 848 EXPECT_EQ(offline_page_2.url, offline_pages_[0].url); | |
| 849 EXPECT_EQ(offline_page_2.offline_id, offline_pages_[0].offline_id); | |
| 850 EXPECT_EQ(offline_page_2.file_path, offline_pages_[0].file_path); | |
| 851 EXPECT_EQ(offline_page_2.file_size, offline_pages_[0].file_size); | |
| 852 EXPECT_EQ(offline_page_2.creation_time, offline_pages_[0].creation_time); | |
| 853 EXPECT_EQ(offline_page_2.last_access_time, | |
| 854 offline_pages_[0].last_access_time); | |
| 855 EXPECT_EQ(offline_page_2.access_count, offline_pages_[0].access_count); | |
| 856 EXPECT_EQ(offline_page_2.client_id, offline_pages_[0].client_id); | |
| 857 } | |
| 858 | |
| 859 // Tests updating offline page metadata from the store. | |
| 860 TEST_F(OfflinePageMetadataStoreTest, UpdateOfflinePage) { | |
| 861 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 862 | |
| 863 // First, adds a fresh page. | |
| 864 OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, | |
| 865 base::FilePath(kFilePath), kFileSize); | |
| 866 store->AddOfflinePage(offline_page, | |
| 867 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 868 base::Unretained(this))); | |
| 869 PumpLoop(); | |
| 870 EXPECT_EQ(ADD, last_called_callback_); | |
| 871 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 872 | |
| 873 ClearResults(); | |
| 874 store->GetOfflinePages( | |
| 875 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 876 base::Unretained(this))); | |
| 877 PumpLoop(); | |
| 878 | |
| 879 EXPECT_EQ(LOAD, last_called_callback_); | |
| 880 ASSERT_EQ(1U, offline_pages_.size()); | |
| 881 EXPECT_EQ(offline_page, offline_pages_[0]); | |
| 882 | |
| 883 // Then update some data. | |
| 884 offline_page.file_size = kFileSize + 1; | |
| 885 offline_page.access_count++; | |
| 886 offline_page.original_url = GURL("https://example.com/bar"); | |
| 887 std::vector<OfflinePageItem> items_to_update; | |
| 888 items_to_update.push_back(offline_page); | |
| 889 store->UpdateOfflinePages( | |
| 890 items_to_update, base::Bind(&OfflinePageMetadataStoreTest::UpdateCallback, | |
| 891 base::Unretained(this), UPDATE)); | |
| 892 PumpLoop(); | |
| 893 EXPECT_EQ(UPDATE, last_called_callback_); | |
| 894 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 895 ASSERT_TRUE(last_update_result() != nullptr); | |
| 896 EXPECT_EQ(1UL, last_update_result()->item_statuses.size()); | |
| 897 EXPECT_EQ(ItemActionStatus::SUCCESS, | |
| 898 last_update_result()->item_statuses.begin()->second); | |
| 899 EXPECT_EQ(1UL, last_update_result()->updated_items.size()); | |
| 900 EXPECT_EQ(offline_page, *(last_update_result()->updated_items.begin())); | |
| 901 | |
| 902 ClearResults(); | |
| 903 store->GetOfflinePages( | |
| 904 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 905 base::Unretained(this))); | |
| 906 PumpLoop(); | |
| 907 | |
| 908 EXPECT_EQ(LOAD, last_called_callback_); | |
| 909 ASSERT_EQ(1U, offline_pages_.size()); | |
| 910 EXPECT_EQ(offline_page, offline_pages_[0]); | |
| 911 } | |
| 912 | |
| 913 TEST_F(OfflinePageMetadataStoreTest, ClearAllOfflinePages) { | |
| 914 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 915 | |
| 916 // Add 2 offline pages. | |
| 917 OfflinePageItem offline_page(GURL(kTestURL), 1234LL, kTestClientId1, | |
| 918 base::FilePath(kFilePath), kFileSize); | |
| 919 store->AddOfflinePage(offline_page, | |
| 920 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 921 base::Unretained(this))); | |
| 922 PumpLoop(); | |
| 923 EXPECT_EQ(ADD, last_called_callback_); | |
| 924 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 925 | |
| 926 ClearResults(); | |
| 927 | |
| 928 OfflinePageItem offline_page2(GURL("http://test.com"), 5678LL, kTestClientId2, | |
| 929 base::FilePath(kFilePath), kFileSize); | |
| 930 store->AddOfflinePage(offline_page2, | |
| 931 base::Bind(&OfflinePageMetadataStoreTest::AddCallback, | |
| 932 base::Unretained(this))); | |
| 933 PumpLoop(); | |
| 934 EXPECT_EQ(ADD, last_called_callback_); | |
| 935 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 936 | |
| 937 ClearResults(); | |
| 938 | |
| 939 // Get all pages from the store. | |
| 940 store->GetOfflinePages( | |
| 941 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 942 base::Unretained(this))); | |
| 943 PumpLoop(); | |
| 944 | |
| 945 EXPECT_EQ(LOAD, last_called_callback_); | |
| 946 EXPECT_EQ(2U, offline_pages_.size()); | |
| 947 | |
| 948 // Clear all records from the store. | |
| 949 store->Reset(base::Bind(&OfflinePageMetadataStoreTest::ResetCallback, | |
| 950 base::Unretained(this))); | |
| 951 PumpLoop(); | |
| 952 EXPECT_EQ(RESET, last_called_callback_); | |
| 953 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 954 | |
| 955 ClearResults(); | |
| 956 | |
| 957 // Get all pages from the store. | |
| 958 store->GetOfflinePages( | |
| 959 base::Bind(&OfflinePageMetadataStoreTest::GetOfflinePagesCallback, | |
| 960 base::Unretained(this))); | |
| 961 PumpLoop(); | |
| 962 | |
| 963 EXPECT_EQ(LOAD, last_called_callback_); | |
| 964 ASSERT_EQ(0U, offline_pages_.size()); | |
| 965 } | |
| 966 | |
| 967 TEST_F(OfflinePageMetadataStoreTest, ResetStore) { | |
| 968 std::unique_ptr<OfflinePageMetadataStore> store(BuildStore()); | |
| 969 | |
| 970 store->Reset(base::Bind(&OfflinePageMetadataStoreTest::ResetCallback, | |
| 971 base::Unretained(this))); | |
| 972 PumpLoop(); | |
| 973 EXPECT_EQ(STATUS_TRUE, last_status_); | |
| 974 } | |
| 975 | |
| 976 } // namespace | |
| 977 } // namespace offline_pages | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2819983003:
[Offline Pages] Renaming metadata store test file. (Closed)
