ServiceWorker: Clean up ServiceWorkerDatabaseTest (2)

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 11 matching lines @@
   int64 reg_id;
   int64 res_id;
   int64 ver_id;
 
   AvailableIds() : reg_id(-1), res_id(-1), ver_id(-1) {}
   ~AvailableIds() {}
 };
 
 GURL URL(const GURL& origin, const std::string& path) {
   EXPECT_TRUE(origin.is_valid());
-  GURL out(origin.GetOrigin().spec() + path);
+  EXPECT_EQ(origin, origin.GetOrigin());
+  GURL out(origin.spec() + path);
   EXPECT_TRUE(out.is_valid());
   return out;
 }
 
 Resource CreateResource(int64 resource_id, const GURL& url) {
+  EXPECT_TRUE(url.is_valid());
   Resource resource;
   resource.resource_id = resource_id;
   resource.url = url;
-  EXPECT_TRUE(resource.url.is_valid());
   return resource;
 }
 
 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) {
   return new ServiceWorkerDatabase(path);
 }
 
 ServiceWorkerDatabase* CreateDatabaseInMemory() {
   return new ServiceWorkerDatabase(base::FilePath());
 }
 
 void VerifyRegistrationData(const RegistrationData& expected,
                             const RegistrationData& actual) {
   EXPECT_EQ(expected.registration_id, actual.registration_id);
   EXPECT_EQ(expected.scope, actual.scope);
   EXPECT_EQ(expected.script, actual.script);
   EXPECT_EQ(expected.version_id, actual.version_id);
   EXPECT_EQ(expected.is_active, actual.is_active);
   EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler);
   EXPECT_EQ(expected.last_update_check, actual.last_update_check);
 }
 
 void VerifyResourceRecords(const std::vector<Resource>& expected,
                            const std::vector<Resource>& actual) {
-  EXPECT_EQ(expected.size(), actual.size());
-  if (expected.size() != actual.size())
-    return;
+  ASSERT_EQ(expected.size(), actual.size());
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i].resource_id, actual[i].resource_id);
     EXPECT_EQ(expected[i].url, actual[i].url);
   }
 }
 
 }  // namespace
 
 TEST(ServiceWorkerDatabaseTest, OpenDatabase) {
   base::ScopedTempDir database_dir;
@@ skipping 132 matching lines @@
   data3.script = URL(origin3, "/script3.js");
   data3.version_id = 678;
   ASSERT_TRUE(database->WriteRegistration(data3, resources));
 
   // |origin3| has two registrations.
   RegistrationData data4;
   data4.registration_id = 456;
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 789;
-  ASSERT_EQ(origin3, data4.scope.GetOrigin());
   ASSERT_TRUE(database->WriteRegistration(data4, resources));
 
   origins.clear();
   EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(3U, origins.size());
   EXPECT_TRUE(ContainsKey(origins, origin1));
   EXPECT_TRUE(ContainsKey(origins, origin2));
   EXPECT_TRUE(ContainsKey(origins, origin3));
 
   // |origin3| has another registration, so should not remove it from the
@@ skipping 109 matching lines @@
 
   registrations.clear();
   EXPECT_TRUE(database->GetAllRegistrations(&registrations));
   EXPECT_EQ(4U, registrations.size());
   VerifyRegistrationData(data1, registrations[0]);
   VerifyRegistrationData(data2, registrations[1]);
   VerifyRegistrationData(data3, registrations[2]);
   VerifyRegistrationData(data4, registrations[3]);
 }
 
-// TODO(nhiroki): Record read/write operations using gtest fixture to avoid
-// building expectations by hand. For example, expected purgeable resource ids
-// should be calculated automatically.

[nhiroki, 2014/05/12 15:14:24]

I found this makes test purposes/expectations unclear, so let me drop this TODO.

 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin("http://example.com");
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
 
-  Resource resource1 = CreateResource(1, URL(origin, "/resource1"));
-  Resource resource2 = CreateResource(2, URL(origin, "/resource2"));
+  std::vector<Resource> resources;
+  resources.push_back(CreateResource(1, URL(origin, "/resource1")));
+  resources.push_back(CreateResource(2, URL(origin, "/resource2")));
 
-  std::vector<Resource> resources;
-  resources.push_back(resource1);
-  resources.push_back(resource2);
-
-  // Write |resource1| to the uncommitted list to make sure that writing
+  // Write a resource to the uncommitted list to make sure that writing
   // registration removes resource ids associated with the registration from
   // the uncommitted list.
   std::set<int64> uncommitted_ids;
-  uncommitted_ids.insert(resource1.resource_id);
+  uncommitted_ids.insert(resources[0].resource_id);
   EXPECT_TRUE(database->WriteUncommittedResourceIds(uncommitted_ids));
   std::set<int64> uncommitted_ids_out;
   EXPECT_TRUE(database->GetUncommittedResourceIds(&uncommitted_ids_out));
-  EXPECT_EQ(1u, uncommitted_ids_out.size());
-  EXPECT_TRUE(ContainsKey(uncommitted_ids_out, resource1.resource_id));
+  EXPECT_EQ(uncommitted_ids.size(), uncommitted_ids_out.size());
+  EXPECT_TRUE(ContainsKey(uncommitted_ids_out, resources[0].resource_id));
 
   EXPECT_TRUE(database->WriteRegistration(data, resources));
 
   // Make sure that the registration and resource records are 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);
   VerifyResourceRecords(resources, resources_out);
 
-  // Make sure that |resource1| is removed from the uncommitted list.
+  // Make sure that the resource is removed from the uncommitted list.
   uncommitted_ids_out.clear();
   EXPECT_TRUE(database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_TRUE(uncommitted_ids_out.empty());
 
-  EXPECT_TRUE(database->DeleteRegistration(
-      data.registration_id, data.scope.GetOrigin()));
+  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
 
   // Make sure that the registration and resource records are gone.
   resources_out.clear();
   EXPECT_FALSE(database->ReadRegistration(
       data.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
 
   // Resources should be purgeable because these are no longer referred.
-  std::set<int64> purgeable_resource_ids;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_resource_ids));
-  EXPECT_EQ(2u, purgeable_resource_ids.size());
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource1.resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource2.resource_id));
+  std::set<int64> purgeable_ids_out;
+  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(2u, purgeable_ids_out.size());
+  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[0].resource_id));
+  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[1].resource_id));
 }
 
 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin("http://example.com");
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
 
-  Resource resource1 = CreateResource(1, URL(origin, "/resource1"));
-  Resource resource2 = CreateResource(2, URL(origin, "/resource2"));
-
   std::vector<Resource> resources1;
-  resources1.push_back(resource1);
-  resources1.push_back(resource2);
+  resources1.push_back(CreateResource(1, URL(origin, "/resource1")));
+  resources1.push_back(CreateResource(2, URL(origin, "/resource2")));
 
   EXPECT_TRUE(database->WriteRegistration(data, resources1));
 
   // Make sure that the registration and resource records are 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);
   VerifyResourceRecords(resources1, resources_out);
 
   // Update the registration.
   RegistrationData updated_data = data;
   updated_data.version_id = data.version_id + 1;
-  Resource resource3 = CreateResource(3, URL(origin, "/resource3"));
-  Resource resource4 = CreateResource(4, URL(origin, "/resource4"));
   std::vector<Resource> resources2;
-  resources2.push_back(resource3);
-  resources2.push_back(resource4);
+  resources2.push_back(CreateResource(3, URL(origin, "/resource3")));
+  resources2.push_back(CreateResource(4, URL(origin, "/resource4")));
 
   EXPECT_TRUE(database->WriteRegistration(updated_data, resources2));
 
   // Make sure that |updated_data| is stored and resources referred from |data|
   // is moved to the purgeable list.
   resources_out.clear();
   EXPECT_TRUE(database->ReadRegistration(
       updated_data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(updated_data, data_out);
   VerifyResourceRecords(resources2, resources_out);
 
-  std::set<int64> purgeable_resource_ids;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_resource_ids));
-  EXPECT_EQ(2u, purgeable_resource_ids.size());
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource1.resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource2.resource_id));
+  std::set<int64> purgeable_ids_out;
+  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(2u, purgeable_ids_out.size());
+  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
+  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 }
 
 TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
-
   GURL origin("http://example.com");
 
   // Add registration1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin, "/foo");
   data1.script = URL(origin, "/script1.js");
   data1.version_id = 200;
-  GURL origin1 = data1.scope.GetOrigin();
-
-  Resource resource1 = CreateResource(1, URL(origin, "/resource1"));
-  Resource resource2 = CreateResource(2, URL(origin, "/resource2"));
 
   std::vector<Resource> resources1;
-  resources1.push_back(resource1);
-  resources1.push_back(resource2);
+  resources1.push_back(CreateResource(1, URL(origin, "/resource1")));
+  resources1.push_back(CreateResource(2, URL(origin, "/resource2")));
   EXPECT_TRUE(database->WriteRegistration(data1, resources1));
 
   // Add registration2.
   RegistrationData data2;
   data2.registration_id = 101;
   data2.scope = URL(origin, "/bar");
   data2.script = URL(origin, "/script2.js");
   data2.version_id = 201;
-  GURL origin2 = data2.scope.GetOrigin();
-
-  Resource resource3 = CreateResource(3, URL(origin, "/resource3"));
-  Resource resource4 = CreateResource(4, URL(origin, "/resource4"));
 
   std::vector<Resource> resources2;
-  resources2.push_back(resource3);
-  resources2.push_back(resource4);
+  resources2.push_back(CreateResource(3, URL(origin, "/resource3")));
+  resources2.push_back(CreateResource(4, URL(origin, "/resource4")));
   EXPECT_TRUE(database->WriteRegistration(data2, resources2));
 
   // Make sure that registration1 is stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_TRUE(database->ReadRegistration(
       data1.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data1, data_out);
   VerifyResourceRecords(resources1, resources_out);
 
   // Make sure that registration2 is also stored.
   resources_out.clear();
   EXPECT_TRUE(database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
 
-  std::set<int64> purgeable_resource_ids;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_resource_ids));
-  EXPECT_TRUE(purgeable_resource_ids.empty());
+  std::set<int64> purgeable_ids_out;
+  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_TRUE(purgeable_ids_out.empty());
 
   // Delete registration1.
   EXPECT_TRUE(database->DeleteRegistration(data1.registration_id, origin));
 
   // Make sure that registration1 is gone.
   resources_out.clear();
   EXPECT_FALSE(database->ReadRegistration(
       data1.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
 
-  purgeable_resource_ids.clear();
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_resource_ids));
-  EXPECT_EQ(2u, purgeable_resource_ids.size());
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource1.resource_id));
-  EXPECT_TRUE(ContainsKey(purgeable_resource_ids, resource2.resource_id));
+  purgeable_ids_out.clear();
+  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(2u, purgeable_ids_out.size());
+  EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
+  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, 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));
 
   std::set<int64> ids_out;
   EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
-  EXPECT_EQ(ids1.size(), ids_out.size());
-  EXPECT_TRUE(base::STLIncludes(ids1, ids_out));
+  EXPECT_EQ(ids1, ids_out);
 
   // Write {2, 4}.
   std::set<int64> ids2;
   ids2.insert(2);
   ids2.insert(4);
   EXPECT_TRUE(database->WriteUncommittedResourceIds(ids2));
 
   ids_out.clear();
   EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
-  EXPECT_EQ(4U, ids_out.size());
-  EXPECT_TRUE(ContainsKey(ids_out, 1));
-  EXPECT_TRUE(ContainsKey(ids_out, 2));
-  EXPECT_TRUE(ContainsKey(ids_out, 3));
-  EXPECT_TRUE(ContainsKey(ids_out, 4));
+  std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
+  EXPECT_EQ(expected, ids_out);
 
   // Delete {2, 3}.
   std::set<int64> ids3;
   ids3.insert(2);
   ids3.insert(3);
   EXPECT_TRUE(database->ClearUncommittedResourceIds(ids3));
 
   ids_out.clear();
   EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
-  EXPECT_EQ(2U, ids_out.size());
-  EXPECT_TRUE(ContainsKey(ids_out, 1));
-  EXPECT_TRUE(ContainsKey(ids_out, 4));
+  expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
+  EXPECT_EQ(expected, ids_out);
 }
 
 TEST(ServiceWorkerDatabaseTest, PurgeableResourceIds) {
   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->WritePurgeableResourceIds(ids1));
 
   std::set<int64> ids_out;
   EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
-  EXPECT_EQ(ids1.size(), ids_out.size());
-  EXPECT_TRUE(base::STLIncludes(ids1, ids_out));
+  EXPECT_EQ(ids1, ids_out);
 
   // Write {2, 4}.
   std::set<int64> ids2;
   ids2.insert(2);
   ids2.insert(4);
   EXPECT_TRUE(database->WritePurgeableResourceIds(ids2));
 
   ids_out.clear();
   EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
-  EXPECT_EQ(4U, ids_out.size());
-  EXPECT_TRUE(ContainsKey(ids_out, 1));
-  EXPECT_TRUE(ContainsKey(ids_out, 2));
-  EXPECT_TRUE(ContainsKey(ids_out, 3));
-  EXPECT_TRUE(ContainsKey(ids_out, 4));
+  std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
+  EXPECT_EQ(expected, ids_out);
 
   // Delete {2, 3}.
   std::set<int64> ids3;
   ids3.insert(2);
   ids3.insert(3);
   EXPECT_TRUE(database->ClearPurgeableResourceIds(ids3));
 
   ids_out.clear();
   EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
-  EXPECT_EQ(2U, ids_out.size());
-  EXPECT_TRUE(ContainsKey(ids_out, 1));
-  EXPECT_TRUE(ContainsKey(ids_out, 4));
+  expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
+  EXPECT_EQ(expected, ids_out);
 }
 
 TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   // Data associated with |origin1| will be removed.
   GURL origin1("http://example.com");
   GURL origin2("http://example.org");
 
   // |origin1| has two registrations.
@@ skipping 56 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