Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(85)

Side by Side Diff: content/browser/service_worker/service_worker_database_unittest.cc

Issue 248803003: ServiceWorker: Store registration data in ServiceWorkerDatabase (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "content/browser/service_worker/service_worker_database.h" 5 #include "content/browser/service_worker/service_worker_database.h"
6 6
7 #include "base/files/scoped_temp_dir.h" 7 #include "base/files/scoped_temp_dir.h"
8 #include "base/stl_util.h"
9 #include "content/browser/service_worker/service_worker_database.pb.h"
8 #include "testing/gtest/include/gtest/gtest.h" 10 #include "testing/gtest/include/gtest/gtest.h"
9 11
10 namespace content { 12 namespace content {
11 13
12 namespace { 14 namespace {
13 15
14 struct AvailableIds { 16 struct AvailableIds {
15 int64 reg_id; 17 int64 reg_id;
16 int64 res_id; 18 int64 res_id;
17 int64 ver_id; 19 int64 ver_id;
18 20
19 AvailableIds() : reg_id(-1), res_id(-1), ver_id(-1) {} 21 AvailableIds() : reg_id(-1), res_id(-1), ver_id(-1) {}
20 ~AvailableIds() {} 22 ~AvailableIds() {}
21 }; 23 };
22 24
23 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) { 25 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) {
24 return new ServiceWorkerDatabase(path); 26 return new ServiceWorkerDatabase(path);
25 } 27 }
26 28
27 ServiceWorkerDatabase* CreateDatabaseInMemory() { 29 ServiceWorkerDatabase* CreateDatabaseInMemory() {
28 return new ServiceWorkerDatabase(base::FilePath()); 30 return new ServiceWorkerDatabase(base::FilePath());
29 } 31 }
30 32
33 void VerifyRegistrationData(
34 const ServiceWorkerRegistrationData& expected,
35 const ServiceWorkerRegistrationData& actual) {
36 EXPECT_EQ(expected.registration_id(), actual.registration_id());
37 EXPECT_EQ(expected.scope_url(), actual.scope_url());
38 EXPECT_EQ(expected.script_url(), actual.script_url());
39 EXPECT_EQ(expected.version_id(), actual.version_id());
40 }
41
42 void VerifyResourceRecords(
43 const std::vector<ServiceWorkerResourceRecord>& expected,
44 const std::vector<ServiceWorkerResourceRecord>& actual) {
45 EXPECT_EQ(expected.size(), actual.size());
46 if (expected.size() != actual.size())
47 return;
48 for (size_t i = 0; i < expected.size(); ++i) {
49 EXPECT_EQ(expected[i].resource_id(), actual[i].resource_id());
50 EXPECT_EQ(expected[i].url(), actual[i].url());
51 }
52 }
53
31 } // namespace 54 } // namespace
32 55
33 TEST(ServiceWorkerDatabaseTest, OpenDatabase) { 56 TEST(ServiceWorkerDatabaseTest, OpenDatabase) {
34 base::ScopedTempDir database_dir; 57 base::ScopedTempDir database_dir;
35 ASSERT_TRUE(database_dir.CreateUniqueTempDir()); 58 ASSERT_TRUE(database_dir.CreateUniqueTempDir());
36 scoped_ptr<ServiceWorkerDatabase> database( 59 scoped_ptr<ServiceWorkerDatabase> database(
37 CreateDatabase(database_dir.path())); 60 CreateDatabase(database_dir.path()));
38 61
39 // Should be false because the database does not exist at the path. 62 // Should be false because the database does not exist at the path.
40 EXPECT_FALSE(database->LazyOpen(false)); 63 EXPECT_FALSE(database->LazyOpen(false));
(...skipping 25 matching lines...) Expand all
66 EXPECT_FALSE(database->GetNextAvailableIds( 89 EXPECT_FALSE(database->GetNextAvailableIds(
67 &ids.reg_id, &ids.ver_id, &ids.res_id)); 90 &ids.reg_id, &ids.ver_id, &ids.res_id));
68 91
69 ASSERT_TRUE(database->LazyOpen(true)); 92 ASSERT_TRUE(database->LazyOpen(true));
70 EXPECT_TRUE(database->GetNextAvailableIds( 93 EXPECT_TRUE(database->GetNextAvailableIds(
71 &ids.reg_id, &ids.ver_id, &ids.res_id)); 94 &ids.reg_id, &ids.ver_id, &ids.res_id));
72 EXPECT_EQ(0, ids.reg_id); 95 EXPECT_EQ(0, ids.reg_id);
73 EXPECT_EQ(0, ids.ver_id); 96 EXPECT_EQ(0, ids.ver_id);
74 EXPECT_EQ(0, ids.res_id); 97 EXPECT_EQ(0, ids.res_id);
75 98
76 // TODO(nhiroki): Test GetNextAvailableIds() after update these ids. 99 // Writing a registration bumps the next available ids.
100 std::vector<ServiceWorkerResourceRecord> resources;
101 ServiceWorkerRegistrationData data;
102 data.set_registration_id(100);
103 data.set_scope_url("http://example.com/foo");
104 data.set_script_url("http://example.com/script.js");
105 data.set_version_id(200);
106 ASSERT_TRUE(database->WriteRegistration(data, resources));
107
108 EXPECT_TRUE(database->GetNextAvailableIds(
109 &ids.reg_id, &ids.ver_id, &ids.res_id));
110 EXPECT_EQ(101, ids.reg_id);
111 EXPECT_EQ(201, ids.ver_id);
112 EXPECT_EQ(0, ids.res_id);
113 }
114
115 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
116 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
117
118 std::set<GURL> origins;
119 EXPECT_FALSE(database->GetOriginsWithRegistrations(&origins));
120
121 std::vector<ServiceWorkerResourceRecord> resources;
122
123 ServiceWorkerRegistrationData data1;
124 data1.set_registration_id(123);
125 data1.set_scope_url("http://example.com/foo");
126 data1.set_script_url("http://example.com/script1.js");
127 data1.set_version_id(456);
128 ASSERT_TRUE(database->WriteRegistration(data1, resources));
129
130 ServiceWorkerRegistrationData data2;
131 data2.set_registration_id(234);
132 data2.set_scope_url("https://www.example.com/bar");
133 data2.set_script_url("https://www.example.com/script2.js");
134 data2.set_version_id(567);
135 ASSERT_TRUE(database->WriteRegistration(data2, resources));
136
137 ServiceWorkerRegistrationData data3;
138 data3.set_registration_id(345);
139 data3.set_scope_url("https://example.org/hoge");
140 data3.set_script_url("https://example.org/script3.js");
141 data3.set_version_id(678);
142 ASSERT_TRUE(database->WriteRegistration(data3, resources));
143
144 // Same origin with |data3|.
145 ServiceWorkerRegistrationData data4;
146 data4.set_registration_id(456);
147 data4.set_scope_url("https://example.org/fuga");
148 data4.set_script_url("https://example.org/script4.js");
149 data4.set_version_id(789);
150 ASSERT_TRUE(database->WriteRegistration(data4, resources));
151
152 EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
153 EXPECT_EQ(3U, origins.size());
154 EXPECT_TRUE(ContainsKey(origins, GURL("http://example.com")));
155 EXPECT_TRUE(ContainsKey(origins, GURL("https://www.example.com")));
156 EXPECT_TRUE(ContainsKey(origins, GURL("https://example.org")));
157 }
158
159 TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
160 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
161
162 GURL origin("https://example.org");
163 std::vector<ServiceWorkerRegistrationData> registrations;
164 EXPECT_FALSE(database->GetRegistrationsForOrigin(origin, &registrations));
165
166 std::vector<ServiceWorkerResourceRecord> resources;
167
168 ServiceWorkerRegistrationData data1;
169 data1.set_registration_id(100);
170 data1.set_scope_url("http://example.com/foo");
171 data1.set_script_url("http://example.com/script1.js");
172 data1.set_version_id(1000);
173 ASSERT_TRUE(database->WriteRegistration(data1, resources));
174
175 ServiceWorkerRegistrationData data2;
176 data2.set_registration_id(200);
177 data2.set_scope_url("https://www.example.com/bar");
178 data2.set_script_url("https://www.example.com/script2.js");
179 data2.set_version_id(2000);
180 ASSERT_TRUE(database->WriteRegistration(data2, resources));
181
182 ServiceWorkerRegistrationData data3;
183 data3.set_registration_id(300);
184 data3.set_scope_url("https://example.org/hoge");
185 data3.set_script_url("https://example.org/script3.js");
186 data3.set_version_id(3000);
187 ASSERT_TRUE(database->WriteRegistration(data3, resources));
188
189 // Same origin with |data3|.
190 ServiceWorkerRegistrationData data4;
191 data4.set_registration_id(400);
192 data4.set_scope_url("https://example.org/fuga");
193 data4.set_script_url("https://example.org/script4.js");
194 data4.set_version_id(4000);
195 ASSERT_TRUE(database->WriteRegistration(data4, resources));
196
197 EXPECT_TRUE(database->GetRegistrationsForOrigin(origin, &registrations));
198 EXPECT_EQ(2U, registrations.size());
199 VerifyRegistrationData(data3, registrations[0]);
200 VerifyRegistrationData(data4, registrations[1]);
201 }
202
203 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
204 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
205
206 ServiceWorkerRegistrationData data;
207 data.set_registration_id(100);
208 data.set_scope_url("http://example.com/foo");
209 data.set_script_url("http://example.com/script.js");
210 data.set_version_id(200);
211
212 ServiceWorkerResourceRecord resource1;
213 resource1.set_resource_id(1);
214 resource1.set_url("http://example.com/resource1");
215 ServiceWorkerResourceRecord resource2;
216 resource2.set_resource_id(2);
217 resource2.set_url("http://example.com/resource2");
218
219 std::vector<ServiceWorkerResourceRecord> resources;
220 resources.push_back(resource1);
221 resources.push_back(resource2);
222
223 database->WriteRegistration(data, resources);
224
225 ServiceWorkerRegistrationData data_out;
226 std::vector<ServiceWorkerResourceRecord> resources_out;
227 database->ReadRegistration(data.registration_id(), &data_out, &resources_out);
228
229 VerifyRegistrationData(data, data_out);
230 VerifyResourceRecords(resources, resources_out);
231 }
232
233 TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
234 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
235
236 // Registration 1.
237 ServiceWorkerRegistrationData data1;
238 data1.set_registration_id(123);
239 data1.set_scope_url("http://example.com/foo");
240 data1.set_script_url("http://example.com/script1.js");
241 data1.set_version_id(100);
242
243 ServiceWorkerResourceRecord resource1;
244 resource1.set_resource_id(1);
245 resource1.set_url("http://example.com/resource1");
246 ServiceWorkerResourceRecord resource2;
247 resource2.set_resource_id(2);
248 resource2.set_url("http://example.com/resource2");
249
250 std::vector<ServiceWorkerResourceRecord> resources1;
251 resources1.push_back(resource1);
252 resources1.push_back(resource2);
253 database->WriteRegistration(data1, resources1);
254
255 // Registration 2.
256 ServiceWorkerRegistrationData data2;
257 data2.set_registration_id(456);
258 data2.set_scope_url("http://example.com/bar");
259 data2.set_script_url("http://example.com/script2.js");
260 data2.set_version_id(200);
261
262 ServiceWorkerResourceRecord resource3;
263 resource3.set_resource_id(10);
264 resource3.set_url("http://example.com/resource3");
265
266 std::vector<ServiceWorkerResourceRecord> resources2;
267 resources2.push_back(resource1); // Same resource with the registration 1.
268 resources2.push_back(resource3);
269 database->WriteRegistration(data2, resources2);
270
271 ServiceWorkerRegistrationData data_out;
272 std::vector<ServiceWorkerResourceRecord> resources_out;
273 database->ReadRegistration(
274 data1.registration_id(), &data_out, &resources_out);
275
276 VerifyRegistrationData(data1, data_out);
277 VerifyResourceRecords(resources1, resources_out);
278 }
279
280 TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
281 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
282
283 std::set<int64> ids1;
284 ids1.insert(1);
285 ids1.insert(2);
286 ids1.insert(3);
287
288 // Write {1, 2, 3}
289 EXPECT_TRUE(database->WriteUncommittedResourceIds(ids1));
290
291 std::set<int64> ids_out;
292 EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
293 EXPECT_EQ(ids1.size(), ids_out.size());
294 EXPECT_TRUE(base::STLIncludes(ids1, ids_out));
295
296 std::set<int64> ids2;
297 ids2.insert(2);
298 ids2.insert(4);
299
300 // Write {2, 4}
301 EXPECT_TRUE(database->WriteUncommittedResourceIds(ids2));
302
303 ids_out.clear();
304 EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
305 EXPECT_EQ(4U, ids_out.size());
306 EXPECT_TRUE(ContainsKey(ids_out, 1));
307 EXPECT_TRUE(ContainsKey(ids_out, 2));
308 EXPECT_TRUE(ContainsKey(ids_out, 3));
309 EXPECT_TRUE(ContainsKey(ids_out, 4));
310
311 // Remove {2, 4}.
312 EXPECT_TRUE(database->ClearUncommittedResourceIds(ids2));
313
314 ids_out.clear();
315 EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
316 EXPECT_EQ(2U, ids_out.size());
317 EXPECT_TRUE(ContainsKey(ids_out, 1));
318 EXPECT_TRUE(ContainsKey(ids_out, 3));
77 } 319 }
78 320
79 } // namespace content 321 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698