OLD | NEW |
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 Loading... |
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, ®istrations)); |
| 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, ®istrations)); |
| 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 |
OLD | NEW |