Linux native notifications: Add notify and close tests

chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc

Index: chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc
diff --git a/chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc b/chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc
index d3e8fa0a4698825560524d681616f25d39ec865c..06b4db6a6b8276f08876237a04f2f90dc9d82e2f 100644
--- a/chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc
+++ b/chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc
@@ -11,7 +11,9 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/notifications/notification.h"
+#include "chrome/browser/notifications/notification_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "dbus/mock_bus.h"
@@ -21,6 +23,10 @@
 
 namespace {
 
+using testing::_;
+using testing::Return;
+using testing::StrictMock;

[Peter Beverloo, 2017/05/04 14:43:06]

nit: move outside of the anonymous namespace

[Tom (Use chromium acct), 2017/05/04 18:15:36]

Done.

+
 const char kFreedesktopNotificationsName[] = "org.freedesktop.Notifications";
 const char kFreedesktopNotificationsPath[] = "/org/freedesktop/Notifications";
 
@@ -38,6 +44,77 @@ ACTION_P(OnGetCapabilities, capabilities) {
   return response;
 }
 
+ACTION_P(OnNotify, id) {
+  dbus::MethodCall* method_call = arg0;
+  dbus::MessageReader reader(method_call);
+  std::string str;
+  uint32_t uint32;
+  int32_t int32;
+  EXPECT_TRUE(reader.PopString(&str));

[Peter Beverloo, 2017/05/04 14:43:06]

nit: this method expects data in a very particular order, so it would be useful
to link to the documentation.

https://developer.gnome.org/notification-spec/#command-notify

[Tom (Use chromium acct), 2017/05/04 18:15:36]

Done.

+  EXPECT_TRUE(reader.PopUint32(&uint32));
+  EXPECT_TRUE(reader.PopString(&str));
+  EXPECT_TRUE(reader.PopString(&str));
+  EXPECT_TRUE(reader.PopString(&str));
+
+  {
+    dbus::MessageReader actions_reader(nullptr);
+    EXPECT_TRUE(reader.PopArray(&actions_reader));
+    while (actions_reader.HasMoreData()) {
+      // Actions come in pairs.
+      EXPECT_TRUE(actions_reader.PopString(&str));
+      EXPECT_TRUE(actions_reader.PopString(&str));
+    }
+  }
+
+  {
+    dbus::MessageReader hints_reader(nullptr);
+    EXPECT_TRUE(reader.PopArray(&hints_reader));
+    while (hints_reader.HasMoreData()) {
+      dbus::MessageReader dict_entry_reader(nullptr);
+      EXPECT_TRUE(hints_reader.PopDictEntry(&dict_entry_reader));
+      EXPECT_TRUE(dict_entry_reader.PopString(&str));
+      dbus::MessageReader variant_reader(nullptr);
+      EXPECT_TRUE(dict_entry_reader.PopVariant(&variant_reader));
+      EXPECT_FALSE(dict_entry_reader.HasMoreData());
+    }
+  }
+
+  EXPECT_TRUE(reader.PopInt32(&int32));
+  EXPECT_FALSE(reader.HasMoreData());
+
+  dbus::Response* response = dbus::Response::CreateEmpty().release();
+  dbus::MessageWriter writer(response);
+  writer.AppendUint32(id);
+  return response;
+}
+
+ACTION(OnCloseNotification) {
+  dbus::MethodCall* method_call = arg0;
+  dbus::MessageReader reader(method_call);
+  uint32_t uint32;
+  EXPECT_TRUE(reader.PopUint32(&uint32));
+  EXPECT_FALSE(reader.HasMoreData());
+
+  return dbus::Response::CreateEmpty().release();
+}
+
+// Matches a method call to the specified dbus target.
+MATCHER_P(Calls, member, "") {
+  return arg->GetMember() == member;
+}
+
+Notification CreateNotification(const char* title,
+                                const char* body,
+                                const char* origin) {
+  message_center::RichNotificationData optional_fields;
+  GURL url = GURL(origin);
+  return Notification(message_center::NOTIFICATION_TYPE_SIMPLE,
+                      base::UTF8ToUTF16(title), base::UTF8ToUTF16(body),
+                      gfx::Image(), message_center::NotifierId(url),
+                      base::UTF8ToUTF16("Notifier's Name"), url, "id1",

[Peter Beverloo, 2017/05/04 14:43:06]

Note that including "id1" (or any static value) means posting this notification
multiple times will cause it to replace the former one. If you do end up testing
notification replacement, enabling the caller to pass in the ID might be useful.

[Tom (Use chromium acct), 2017/05/04 18:15:36]

Done.

+                      optional_fields, new MockNotificationDelegate("id1"));
+}
+
 }  // namespace
 
 class NotificationPlatformBridgeLinuxTest : public testing::Test {
@@ -47,27 +124,27 @@ class NotificationPlatformBridgeLinuxTest : public testing::Test {
 
   void SetUp() override {
     mock_bus_ = new dbus::MockBus(dbus::Bus::Options());
-    mock_notification_proxy_ = new testing::StrictMock<dbus::MockObjectProxy>(
+    mock_notification_proxy_ = new StrictMock<dbus::MockObjectProxy>(
         mock_bus_.get(), kFreedesktopNotificationsName,
         dbus::ObjectPath(kFreedesktopNotificationsPath));
 
     EXPECT_CALL(*mock_bus_.get(),
                 GetObjectProxy(kFreedesktopNotificationsName,
                                dbus::ObjectPath(kFreedesktopNotificationsPath)))
-        .WillOnce(testing::Return(mock_notification_proxy_.get()));
+        .WillOnce(Return(mock_notification_proxy_.get()));
 
     EXPECT_CALL(*mock_notification_proxy_.get(),
-                MockCallMethodAndBlock(testing::_, testing::_))
+                MockCallMethodAndBlock(Calls("GetCapabilities"), _))
         .WillOnce(OnGetCapabilities(std::vector<std::string>()));
 
-    EXPECT_CALL(*mock_notification_proxy_.get(),
-                ConnectToSignal(kFreedesktopNotificationsName, "ActionInvoked",
-                                testing::_, testing::_))
+    EXPECT_CALL(
+        *mock_notification_proxy_.get(),
+        ConnectToSignal(kFreedesktopNotificationsName, "ActionInvoked", _, _))
         .WillOnce(RegisterSignalCallback(&action_invoked_callback_));
 
     EXPECT_CALL(*mock_notification_proxy_.get(),
                 ConnectToSignal(kFreedesktopNotificationsName,
-                                "NotificationClosed", testing::_, testing::_))
+                                "NotificationClosed", _, _))
         .WillOnce(RegisterSignalCallback(&notification_closed_callback_));
 
     notification_bridge_linux_ =
@@ -99,3 +176,16 @@ class NotificationPlatformBridgeLinuxTest : public testing::Test {
 };
 
 TEST_F(NotificationPlatformBridgeLinuxTest, SetUpAndTearDown) {}
+
+TEST_F(NotificationPlatformBridgeLinuxTest, NotifyAndCloseFormat) {
+  EXPECT_CALL(*mock_notification_proxy_.get(),
+              MockCallMethodAndBlock(Calls("Notify"), _))
+      .WillOnce(OnNotify(1));
+  notification_bridge_linux_->Display(NotificationCommon::PERSISTENT, "", "",
+                                      false, CreateNotification("", "", ""));
+
+  EXPECT_CALL(*mock_notification_proxy_.get(),
+              MockCallMethodAndBlock(Calls("CloseNotification"), _))
+      .WillOnce(OnCloseNotification());
+  notification_bridge_linux_->Close("", "");
+}