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 "chrome/browser/offline_pages/offline_page_metadata_store_impl.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/files/file_path.h" | |
9 #include "base/files/scoped_temp_dir.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/message_loop/message_loop.h" | |
12 #include "base/run_loop.h" | |
13 #include "base/strings/utf_string_conversions.h" | |
14 #include "chrome/browser/offline_pages/offline_pages.pb.h" | |
15 #include "components/leveldb_proto/proto_database_impl.h" | |
16 #include "components/offline_pages/offline_page_item.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 | |
19 using leveldb_proto::ProtoDatabaseImpl; | |
20 | |
21 namespace offline_pages { | |
22 | |
23 namespace { | |
24 | |
25 const char kTestURL[] = "https://example.com"; | |
26 const base::string16 kTestTitle = base::ASCIIToUTF16("Example site title"); | |
27 const base::FilePath::CharType kFilePath[] = | |
28 FILE_PATH_LITERAL("/offline_pages/example_com.mhtml"); | |
29 int64 kFileSize = 234567; | |
30 | |
31 class OfflinePageMetadataStoreImplTest : public testing::Test { | |
32 public: | |
33 enum CalledCallback { NONE, LOAD, ADD, REMOVE, DESTROY }; | |
34 enum Status { STATUS_NONE, STATUS_TRUE, STATUS_FALSE }; | |
35 | |
36 OfflinePageMetadataStoreImplTest(); | |
37 ~OfflinePageMetadataStoreImplTest() override; | |
38 | |
39 void TearDown() override { message_loop_.RunUntilIdle(); } | |
40 | |
41 scoped_ptr<OfflinePageMetadataStoreImpl> BuildStore(); | |
42 void PumpLoop(); | |
43 | |
44 void LoadCallback(bool success, | |
45 const std::vector<OfflinePageItem>& offline_pages); | |
46 void UpdateCallback(CalledCallback called_callback, bool success); | |
47 | |
48 void ClearResults(); | |
49 | |
50 protected: | |
51 CalledCallback last_called_callback_; | |
52 Status last_status_; | |
53 std::vector<OfflinePageItem> offline_pages_; | |
54 | |
55 base::ScopedTempDir temp_directory_; | |
56 base::MessageLoop message_loop_; | |
57 scoped_ptr<base::RunLoop> run_loop_; | |
58 }; | |
59 | |
60 OfflinePageMetadataStoreImplTest::OfflinePageMetadataStoreImplTest() | |
61 : last_called_callback_(NONE), last_status_(STATUS_NONE) { | |
62 EXPECT_TRUE(temp_directory_.CreateUniqueTempDir()); | |
63 } | |
64 | |
65 OfflinePageMetadataStoreImplTest::~OfflinePageMetadataStoreImplTest() { | |
66 } | |
67 | |
68 void OfflinePageMetadataStoreImplTest::PumpLoop() { | |
69 run_loop_.reset(new base::RunLoop()); | |
70 run_loop_->Run(); | |
71 } | |
72 | |
73 scoped_ptr<OfflinePageMetadataStoreImpl> | |
74 OfflinePageMetadataStoreImplTest::BuildStore() { | |
75 scoped_ptr<ProtoDatabaseImpl<offline_pages::OfflinePageEntry>> db( | |
76 new ProtoDatabaseImpl<offline_pages::OfflinePageEntry>( | |
77 message_loop_.task_runner())); | |
78 return scoped_ptr<OfflinePageMetadataStoreImpl>( | |
79 new OfflinePageMetadataStoreImpl(db.Pass(), temp_directory_.path())); | |
80 } | |
81 | |
82 void OfflinePageMetadataStoreImplTest::LoadCallback( | |
83 bool status, | |
84 const std::vector<OfflinePageItem>& offline_pages) { | |
85 last_called_callback_ = LOAD; | |
86 last_status_ = status ? STATUS_TRUE : STATUS_FALSE; | |
87 offline_pages_.swap(const_cast<std::vector<OfflinePageItem>&>(offline_pages)); | |
88 run_loop_->Quit(); | |
89 } | |
90 | |
91 void OfflinePageMetadataStoreImplTest::UpdateCallback( | |
92 CalledCallback called_callback, | |
93 bool status) { | |
94 last_called_callback_ = called_callback; | |
95 last_status_ = status ? STATUS_TRUE : STATUS_FALSE; | |
96 run_loop_->Quit(); | |
97 } | |
98 | |
99 void OfflinePageMetadataStoreImplTest::ClearResults() { | |
100 last_called_callback_ = NONE; | |
101 last_status_ = STATUS_NONE; | |
102 offline_pages_.clear(); | |
103 } | |
104 | |
105 // Loads empty store and makes sure that there are no offline pages stored in | |
106 // it. | |
107 TEST_F(OfflinePageMetadataStoreImplTest, LoadEmptyStore) { | |
108 scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore()); | |
109 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
110 base::Unretained(this))); | |
111 PumpLoop(); | |
112 | |
113 EXPECT_EQ(LOAD, last_called_callback_); | |
114 EXPECT_EQ(STATUS_TRUE, last_status_); | |
115 EXPECT_EQ(0U, offline_pages_.size()); | |
116 } | |
117 | |
118 // Adds metadata of an offline page into a store and then loads from the | |
119 // store to make sure the metadata is preserved. | |
120 TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageThenLoad) { | |
121 scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore()); | |
122 | |
123 OfflinePageItem offline_page(GURL(kTestURL), kTestTitle, | |
124 base::FilePath(kFilePath), kFileSize); | |
125 store->AddOfflinePage( | |
126 offline_page, | |
127 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
128 base::Unretained(this), ADD)); | |
129 PumpLoop(); | |
130 EXPECT_EQ(ADD, last_called_callback_); | |
131 EXPECT_EQ(STATUS_TRUE, last_status_); | |
132 | |
133 ClearResults(); | |
134 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
135 base::Unretained(this))); | |
136 PumpLoop(); | |
137 | |
138 EXPECT_EQ(LOAD, last_called_callback_); | |
139 EXPECT_EQ(STATUS_TRUE, last_status_); | |
140 EXPECT_EQ(1U, offline_pages_.size()); | |
141 EXPECT_EQ(offline_page.url, offline_pages_[0].url); | |
142 EXPECT_EQ(offline_page.title, offline_pages_[0].title); | |
143 EXPECT_EQ(offline_page.version, offline_pages_[0].version); | |
144 EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path); | |
145 EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size); | |
146 EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time); | |
147 EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time); | |
148 } | |
149 | |
150 // Adds metadata of an offline page into a store and then opens the store | |
151 // again to make sure that stored metadata survives store restarts. | |
152 TEST_F(OfflinePageMetadataStoreImplTest, AddOfflinePageRestartLoad) { | |
153 scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore()); | |
154 | |
155 OfflinePageItem offline_page(GURL(kTestURL), kTestTitle, | |
156 base::FilePath(kFilePath), kFileSize); | |
157 store->AddOfflinePage( | |
158 offline_page, | |
159 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
160 base::Unretained(this), ADD)); | |
161 PumpLoop(); | |
162 EXPECT_EQ(ADD, last_called_callback_); | |
163 EXPECT_EQ(STATUS_TRUE, last_status_); | |
164 | |
165 // Reset the store first to ensure file lock is removed. | |
166 store.reset(); | |
167 store = BuildStore().Pass(); | |
168 ClearResults(); | |
169 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
170 base::Unretained(this))); | |
171 PumpLoop(); | |
172 | |
173 EXPECT_EQ(LOAD, last_called_callback_); | |
174 EXPECT_EQ(STATUS_TRUE, last_status_); | |
175 EXPECT_EQ(1U, offline_pages_.size()); | |
176 EXPECT_EQ(offline_page.url, offline_pages_[0].url); | |
177 EXPECT_EQ(offline_page.title, offline_pages_[0].title); | |
178 EXPECT_EQ(offline_page.version, offline_pages_[0].version); | |
179 EXPECT_EQ(offline_page.file_path, offline_pages_[0].file_path); | |
180 EXPECT_EQ(offline_page.file_size, offline_pages_[0].file_size); | |
181 EXPECT_EQ(offline_page.creation_time, offline_pages_[0].creation_time); | |
182 EXPECT_EQ(offline_page.last_access_time, offline_pages_[0].last_access_time); | |
183 } | |
184 | |
185 // Tests removing offline page metadata from the store, for which it first adds | |
186 // metadata of an offline page. | |
187 TEST_F(OfflinePageMetadataStoreImplTest, RemoveOfflinePage) { | |
188 scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore()); | |
189 | |
190 OfflinePageItem offline_page(GURL(kTestURL), kTestTitle, | |
191 base::FilePath(kFilePath), kFileSize); | |
192 store->AddOfflinePage( | |
193 offline_page, | |
194 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
195 base::Unretained(this), ADD)); | |
196 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
197 base::Unretained(this))); | |
198 store->RemoveOfflinePage( | |
199 offline_page.url, | |
200 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
201 base::Unretained(this), REMOVE)); | |
202 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
203 base::Unretained(this))); | |
204 store.reset(); | |
205 store = BuildStore().Pass(); | |
206 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
207 base::Unretained(this))); | |
208 // Add offline page is exectued: | |
209 PumpLoop(); | |
210 EXPECT_EQ(ADD, last_called_callback_); | |
211 EXPECT_EQ(STATUS_TRUE, last_status_); | |
212 | |
213 // Load is exectued: | |
214 ClearResults(); | |
215 PumpLoop(); | |
216 | |
217 EXPECT_EQ(LOAD, last_called_callback_); | |
218 EXPECT_EQ(STATUS_TRUE, last_status_); | |
219 EXPECT_EQ(1U, offline_pages_.size()); | |
220 | |
221 // Remove offline page is exectued: | |
222 ClearResults(); | |
223 PumpLoop(); | |
224 EXPECT_EQ(REMOVE, last_called_callback_); | |
225 EXPECT_EQ(STATUS_TRUE, last_status_); | |
226 | |
227 // Load is exectued: | |
228 ClearResults(); | |
229 PumpLoop(); | |
230 | |
231 EXPECT_EQ(LOAD, last_called_callback_); | |
232 EXPECT_EQ(STATUS_TRUE, last_status_); | |
233 EXPECT_EQ(0U, offline_pages_.size()); | |
234 | |
235 // Checking the value after reseting the store. | |
236 ClearResults(); | |
237 PumpLoop(); | |
238 EXPECT_EQ(LOAD, last_called_callback_); | |
239 EXPECT_EQ(STATUS_TRUE, last_status_); | |
240 EXPECT_EQ(0U, offline_pages_.size()); | |
241 } | |
242 | |
243 // Adds metadata of multiple offline pages into a store and removes some. | |
244 TEST_F(OfflinePageMetadataStoreImplTest, AddRemoveMultipleOfflinePages) { | |
245 scoped_ptr<OfflinePageMetadataStoreImpl> store(BuildStore()); | |
246 | |
247 OfflinePageItem offline_page_1(GURL(kTestURL), kTestTitle, | |
248 base::FilePath(kFilePath), kFileSize); | |
249 base::FilePath file_path_2 = | |
250 base::FilePath(FILE_PATH_LITERAL("//other.page.com.mhtml")); | |
251 OfflinePageItem offline_page_2(GURL("https://other.page.com"), | |
252 base::ASCIIToUTF16("Other page"), | |
253 file_path_2, 12345, base::Time::Now()); | |
254 store->AddOfflinePage( | |
255 offline_page_1, | |
256 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
257 base::Unretained(this), ADD)); | |
258 PumpLoop(); | |
259 EXPECT_EQ(ADD, last_called_callback_); | |
260 EXPECT_EQ(STATUS_TRUE, last_status_); | |
261 | |
262 ClearResults(); | |
263 store->AddOfflinePage( | |
264 offline_page_2, | |
265 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
266 base::Unretained(this), ADD)); | |
267 PumpLoop(); | |
268 EXPECT_EQ(ADD, last_called_callback_); | |
269 EXPECT_EQ(STATUS_TRUE, last_status_); | |
270 | |
271 ClearResults(); | |
272 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
273 base::Unretained(this))); | |
274 PumpLoop(); | |
275 | |
276 EXPECT_EQ(LOAD, last_called_callback_); | |
277 EXPECT_EQ(STATUS_TRUE, last_status_); | |
278 EXPECT_EQ(2U, offline_pages_.size()); | |
279 | |
280 store->RemoveOfflinePage( | |
281 offline_page_1.url, | |
282 base::Bind(&OfflinePageMetadataStoreImplTest::UpdateCallback, | |
283 base::Unretained(this), REMOVE)); | |
284 PumpLoop(); | |
285 EXPECT_EQ(REMOVE, last_called_callback_); | |
286 EXPECT_EQ(STATUS_TRUE, last_status_); | |
287 | |
288 ClearResults(); | |
289 store.reset(); | |
290 store = BuildStore().Pass(); | |
291 store->Load(base::Bind(&OfflinePageMetadataStoreImplTest::LoadCallback, | |
292 base::Unretained(this))); | |
293 PumpLoop(); | |
294 | |
295 EXPECT_EQ(LOAD, last_called_callback_); | |
296 EXPECT_EQ(STATUS_TRUE, last_status_); | |
297 EXPECT_EQ(1U, offline_pages_.size()); | |
298 EXPECT_EQ(offline_page_2.url, offline_pages_[0].url); | |
299 EXPECT_EQ(offline_page_2.title, offline_pages_[0].title); | |
300 EXPECT_EQ(offline_page_2.version, offline_pages_[0].version); | |
301 EXPECT_EQ(offline_page_2.file_path, offline_pages_[0].file_path); | |
302 EXPECT_EQ(offline_page_2.file_size, offline_pages_[0].file_size); | |
303 EXPECT_EQ(offline_page_2.creation_time, offline_pages_[0].creation_time); | |
304 EXPECT_EQ(offline_page_2.last_access_time, | |
305 offline_pages_[0].last_access_time); | |
306 } | |
307 | |
308 } // namespace | |
309 | |
310 } // namespace offline_pages | |
OLD | NEW |