The notification database should be able to read or delete multiple items.

content/browser/notifications/notification_database_unittest.cc

 // Copyright 2015 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/notifications/notification_database.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/notification_database_data.h"
@@ skipping 11 matching lines @@
   NotificationDatabase* CreateDatabaseInMemory() {
     return new NotificationDatabase(base::FilePath());
   }
 
   // Creates a new NotificationDatabase instance in |path|.
   NotificationDatabase* CreateDatabaseOnFileSystem(
       const base::FilePath& path) {
     return new NotificationDatabase(path);
   }
 
+  // Creates a new notification for |service_worker_registration_id| belonging
+  // to |origin| and writes it to the database. The written notification id
+  // will be stored in |notification_id|.
+  void CreateAndWriteNotification(NotificationDatabase* database,
+                                  const GURL& origin,
+                                  int64_t service_worker_registration_id,
+                                  int64_t* notification_id) {
+    NotificationDatabaseData database_data;
+    database_data.origin = origin;
+    database_data.service_worker_registration_id =
+        service_worker_registration_id;
+
+    ASSERT_EQ(NotificationDatabase::STATUS_OK,
+              database->WriteNotificationData(origin,
+                                              database_data,
+                                              notification_id));
+  }
+
   // Returns if |database| has been opened.
   bool IsDatabaseOpen(NotificationDatabase* database) {
     return database->IsOpen();
   }
 
   // Returns if |database| is an in-memory only database.
   bool IsInMemoryDatabase(NotificationDatabase* database) {
     return database->IsInMemoryDatabase();
   }
 
@@ skipping 81 matching lines @@
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   scoped_ptr<NotificationDatabase> database(
       CreateDatabaseOnFileSystem(database_dir.path()));
 
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   GURL origin("https://example.com");
 
-  NotificationDatabaseData database_data;
   int64_t notification_id = 0;
 
   // Verify that getting two ids on the same database instance results in
   // incrementing values. Notification ids will start at 1.
-  ASSERT_EQ(NotificationDatabase::STATUS_OK,
-            database->WriteNotificationData(origin,
-                                            database_data,
-                                            &notification_id));
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 1);
 
-  ASSERT_EQ(NotificationDatabase::STATUS_OK,
-            database->WriteNotificationData(origin,
-                                            database_data,
-                                            &notification_id));
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 2);
 
   database.reset(CreateDatabaseOnFileSystem(database_dir.path()));
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(false /* create_if_missing */));
 
   // Verify that the next notification id was stored in the database, and
   // continues where we expect it to be, even after closing and opening it.
-  ASSERT_EQ(NotificationDatabase::STATUS_OK,
-            database->WriteNotificationData(origin,
-                                            database_data,
-                                            &notification_id));
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(), origin, 0 /* sw_registration_id */, &notification_id));
   EXPECT_EQ(notification_id, 3);
 }
 
 TEST_F(NotificationDatabaseTest, NotificationIdCorruption) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 
   scoped_ptr<NotificationDatabase> database(
       CreateDatabaseOnFileSystem(database_dir.path()));
 
@@ skipping 128 matching lines @@
   EXPECT_EQ(notification_data.tag, read_notification_data.tag);
   EXPECT_EQ(notification_data.icon, read_notification_data.icon);
   EXPECT_EQ(notification_data.silent, read_notification_data.silent);
 }
 
 TEST_F(NotificationDatabaseTest, ReadWriteMultipleNotificationData) {
   scoped_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
-  NotificationDatabaseData database_data;
   GURL origin("https://example.com");
+  int64_t notification_id = 0;
 
   // Write ten notifications to the database, each with a unique title and
   // notification id (it is the responsibility of the user to increment this).
   for (int i = 1; i <= 10; ++i) {
-    database_data.notification_id = i;
-    database_data.notification_data.title = base::IntToString16(i);
-
-    int64_t notification_id = 0;
-    ASSERT_EQ(NotificationDatabase::STATUS_OK,
-              database->WriteNotificationData(origin,
-                                              database_data,
-                                              &notification_id));
+    ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+        database.get(), origin, i /* sw_registration_id */, &notification_id));
     EXPECT_EQ(notification_id, i);
   }
 
+  NotificationDatabaseData database_data;
+
   // Read the ten notifications from the database, and verify that the titles
   // of each of them matches with how they were created.
   for (int i = 1; i <= 10; ++i) {
     ASSERT_EQ(NotificationDatabase::STATUS_OK,
               database->ReadNotificationData(i /* notification_id */,
                                              origin,
                                              &database_data));
 
-    EXPECT_EQ(base::IntToString16(i), database_data.notification_data.title);
+    EXPECT_EQ(i, database_data.service_worker_registration_id);
   }
 }
 
 TEST_F(NotificationDatabaseTest, DeleteInvalidNotificationData) {
   scoped_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
             database->Open(true /* create_if_missing */));
 
   // Deleting non-existing notifications is not considered to be a failure.
   ASSERT_EQ(NotificationDatabase::STATUS_OK,
@@ skipping 54 matching lines @@
   EXPECT_EQ(NotificationDatabase::STATUS_OK,
             database->DeleteNotificationData(notification_id,
                                              GURL("https://chrome.com")));
 
   EXPECT_EQ(NotificationDatabase::STATUS_OK,
             database->ReadNotificationData(notification_id,
                                            origin,
                                            &database_data));
 }
 
+TEST_F(NotificationDatabaseTest, ReadAllServiceWorkerNotificationData) {
+  scoped_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->Open(true /* create_if_missing */));
+
+  GURL origin("https://example.com");
+
+  int64_t service_worker_registration_id = 42;
+  int64_t notification_id = 0;
+
+  // Write ten notifications belonging to |origin| to the database.
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+        database.get(),
+        origin,
+        service_worker_registration_id,
+        &notification_id));
+  }
+
+  // Write one notification not belonging to |origin| to the database, but with
+  // the same Service Worker registration id.
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(),
+      GURL("https://foobar.com"),
+      service_worker_registration_id,
+      &notification_id));
+
+  // Write one notification belonging to |origin| to the database, but with a
+  // different Service Worker registration id.
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(),
+      origin,
+      service_worker_registration_id + 1,
+      &notification_id));
+
+  // Read all notifications from the database which belong to |origin| and
+  // |service_worker_registration_id|. There should be ten.
+  std::vector<NotificationDatabaseData> notifications;
+
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadAllNotificationDataForServiceWorkerRegistration(
+                origin,
+                service_worker_registration_id,
+                &notifications));
+
+  EXPECT_EQ(10u, notifications.size());
+}
+
+TEST_F(NotificationDatabaseTest, ReadAllNotificationDataAfterDelete) {
+  scoped_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->Open(true /* create_if_missing */));
+
+  GURL origin("https://example.com");
+
+  int64_t service_worker_registration_id = 42;
+  int64_t notification_id = 0;
+
+  // Write ten notifications belonging to |origin| to the database.
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+        database.get(),
+        origin,
+        service_worker_registration_id,
+        &notification_id));
+  }
+
+  // Remove the most recent notification from the database.
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->DeleteNotificationData(notification_id, origin));
+
+  // Make sure that only nine notifications remain.
+  std::vector<NotificationDatabaseData> notifications;
+
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadAllNotificationDataForServiceWorkerRegistration(
+                origin,
+                service_worker_registration_id,
+                &notifications));
+
+  EXPECT_EQ(9u, notifications.size());
+}
+
+TEST_F(NotificationDatabaseTest, DeleteAllServiceWorkerNotificationData) {
+  scoped_ptr<NotificationDatabase> database(CreateDatabaseInMemory());
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->Open(true /* create_if_missing */));
+
+  GURL origin("https://example.com");
+
+  int64_t service_worker_registration_id = 42;
+  int64_t notification_id = 0;
+
+  // Write ten notifications belonging to |origin| to the database.
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+        database.get(),
+        origin,
+        service_worker_registration_id,
+        &notification_id));
+  }
+
+  // Write one notification to the database with a different Service Worker
+  // registration id, but still the same origin.
+  ASSERT_NO_FATAL_FAILURE(CreateAndWriteNotification(
+      database.get(),
+      origin,
+      service_worker_registration_id + 1,
+      &notification_id));
+
+  std::set<int64_t> deleted_notification_ids;
+
+  // Delete all the notifications from the database which used to belong to the
+  // origin and Service Worker registration id. Ten should be deleted.
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->DeleteAllNotificationDataForServiceWorkerRegistration(
+                origin,
+                service_worker_registration_id,
+                &deleted_notification_ids));
+
+  EXPECT_EQ(10u, deleted_notification_ids.size());
+
+  std::vector<NotificationDatabaseData> notifications;
+
+  // Make sure that all the notifications which are said to be deleted actually
+  // have been removed from the database.
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadAllNotificationDataForServiceWorkerRegistration(
+                origin,
+                service_worker_registration_id,
+                &notifications));
+
+  EXPECT_EQ(0u, notifications.size());
+
+  NotificationDatabaseData database_data;
+
+  // Make sure that the non-associated notification still exists.
+  ASSERT_EQ(NotificationDatabase::STATUS_OK,
+            database->ReadNotificationData(notification_id,
+                                           origin,
+                                           &database_data));
+}
+
 }  // namespace content