ServiceWorker: Add missing tests for ServiceWorkerDatabase

content/browser/service_worker/service_worker_database_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_database.h"
 
 #include <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/stl_util.h"
@@ skipping 501 matching lines @@
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 
   // Make sure that registration2 is still alive.
   resources_out.clear();
   EXPECT_TRUE(database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
 }
 
+TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
+  scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+  GURL origin("http://example.com");
+
+  // Should be false because a registration does not exist.
+  EXPECT_FALSE(database->UpdateVersionToActive(0, origin));
+
+  // Add a registration.
+  RegistrationData data;
+  data.registration_id = 100;
+  data.scope = URL(origin, "/foo");
+  data.script = URL(origin, "/script.js");
+  data.version_id = 200;
+  data.is_active = false;
+  EXPECT_TRUE(database->WriteRegistration(data, std::vector<Resource>()));
+
+  // Make sure that the registration is stored.
+  RegistrationData data_out;
+  std::vector<Resource> resources_out;
+  EXPECT_TRUE(database->ReadRegistration(
+      data.registration_id, origin, &data_out, &resources_out));
+  VerifyRegistrationData(data, data_out);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Activate the registration.
+  EXPECT_TRUE(database->UpdateVersionToActive(data.registration_id, origin));
+
+  // Make sure that the registration is activated.
+  resources_out.clear();
+  EXPECT_TRUE(database->ReadRegistration(
+      data.registration_id, origin, &data_out, &resources_out));
+  RegistrationData expected_data = data;
+  expected_data.is_active = true;
+  VerifyRegistrationData(expected_data, data_out);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Delete the registration.
+  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
+
+  // Should be false because the registration is gone.
+  EXPECT_FALSE(database->UpdateVersionToActive(data.registration_id, origin));
+}
+
+TEST(ServiceWorkerDatabaseTest, UpdateLastCheckTime) {

[nhiroki, 2014/05/16 08:41:56]

Btw, though base::Time could be decreased when a user changes the computer
clock, current UpdateLastCheckTime() does not compare the stored last-check-time
and the given last-check-time, and the given time always wins. Is this right
behavior? I guess this is OK because if a user changes the clock to the far
future and resets it after some registrations are stored, they couldn't be
checked forever. Wdyt?

+  scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+  GURL origin("http://example.com");
+
+  // Should be false because a registration does not exist.
+  EXPECT_FALSE(database->UpdateLastCheckTime(0, origin, base::Time::Now()));
+
+  // Add a registration.
+  RegistrationData data;
+  data.registration_id = 100;
+  data.scope = URL(origin, "/foo");
+  data.script = URL(origin, "/script.js");
+  data.version_id = 200;
+  data.last_update_check = base::Time::Now();
+  EXPECT_TRUE(database->WriteRegistration(data, std::vector<Resource>()));
+
+  // Make sure that the registration is stored.
+  RegistrationData data_out;
+  std::vector<Resource> resources_out;
+  EXPECT_TRUE(database->ReadRegistration(
+      data.registration_id, origin, &data_out, &resources_out));
+  VerifyRegistrationData(data, data_out);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Update the last update check time.
+  base::Time updated_time = base::Time::Now();
+  EXPECT_TRUE(database->UpdateLastCheckTime(
+      data.registration_id, origin, updated_time));
+
+  // Make sure that the registration is updated.
+  resources_out.clear();
+  EXPECT_TRUE(database->ReadRegistration(
+      data.registration_id, origin, &data_out, &resources_out));
+  RegistrationData expected_data = data;
+  expected_data.last_update_check = updated_time;
+  VerifyRegistrationData(expected_data, data_out);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Delete the registration.
+  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
+
+  // Should be false because the registration is gone.
+  EXPECT_FALSE(database->UpdateLastCheckTime(
+      data.registration_id, origin, base::Time::Now()));
+}
+
 TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   // Write {1, 2, 3}.
   std::set<int64> ids1;
   ids1.insert(1);
   ids1.insert(2);
   ids1.insert(3);
   EXPECT_TRUE(database->WriteUncommittedResourceIds(ids1));
 
@@ skipping 129 matching lines @@
   std::set<int64> purgeable_ids_out;
   EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(4u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 3));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 4));
 }
 
 }  // namespace content