Linux native notifications: Require 'actions' and 'body' capabilities

chrome/browser/notifications/notification_platform_bridge_linux_unittest.cc

 // Copyright 2017 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 "chrome/browser/notifications/notification_platform_bridge_linux.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 175 matching lines @@
   // https://developer.gnome.org/notification-spec/#command-close-notification
   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();
 }
 
+ACTION_P(OnNotificationBridgeReady, success) {
+  EXPECT_EQ(success, arg0);
+}
+
 // Matches a method call to the specified dbus target.
 MATCHER_P(Calls, member, "") {
   return arg->GetMember() == member;
 }
 
 }  // namespace
 
 class NotificationPlatformBridgeLinuxTest : public testing::Test {
  public:
   NotificationPlatformBridgeLinuxTest() = default;
   ~NotificationPlatformBridgeLinuxTest() override = default;
 
   void SetUp() override {
     mock_bus_ = new dbus::MockBus(dbus::Bus::Options());
     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(Return(mock_notification_proxy_.get()));
-
-    EXPECT_CALL(*mock_notification_proxy_.get(),
-                MockCallMethodAndBlock(Calls("GetCapabilities"), _))
-        .WillOnce(OnGetCapabilities(std::vector<std::string>{
-            "body", "body-hyperlinks", "body-images", "body-markup"}));
-
-    EXPECT_CALL(
-        *mock_notification_proxy_.get(),
-        ConnectToSignal(kFreedesktopNotificationsName, "ActionInvoked", _, _))
-        .WillOnce(RegisterSignalCallback(&action_invoked_callback_));
-
-    EXPECT_CALL(*mock_notification_proxy_.get(),
-                ConnectToSignal(kFreedesktopNotificationsName,
-                                "NotificationClosed", _, _))
-        .WillOnce(RegisterSignalCallback(&notification_closed_callback_));
   }
 
   void TearDown() override {
-    EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock());
     notification_bridge_linux_->CleanUp();
     content::RunAllBlockingPoolTasksUntilIdle();
     notification_bridge_linux_.reset();
     mock_notification_proxy_ = nullptr;
     mock_bus_ = nullptr;
   }
 
  protected:
   void CreateNotificationBridgeLinux() {
+    CreateNotificationBridgeLinux(
+        std::vector<std::string>{"actions", "body", "body-hyperlinks",
+                                 "body-images", "body-markup"},
+        true, true, true);
+  }
+
+  void CreateNotificationBridgeLinux(
+      const std::vector<std::string>& capabilities,
+      bool expect_init_success,
+      bool expect_shutdown,
+      bool connect_signals) {
+    EXPECT_CALL(*mock_bus_.get(),
+                GetObjectProxy(kFreedesktopNotificationsName,
+                               dbus::ObjectPath(kFreedesktopNotificationsPath)))
+        .WillOnce(Return(mock_notification_proxy_.get()));
+
+    EXPECT_CALL(*mock_notification_proxy_.get(),
+                MockCallMethodAndBlock(Calls("GetCapabilities"), _))
+        .WillOnce(OnGetCapabilities(capabilities));
+
+    if (connect_signals) {
+      EXPECT_CALL(
+          *mock_notification_proxy_.get(),
+          ConnectToSignal(kFreedesktopNotificationsName, "ActionInvoked", _, _))
+          .WillOnce(RegisterSignalCallback(&action_invoked_callback_));
+
+      EXPECT_CALL(*mock_notification_proxy_.get(),
+                  ConnectToSignal(kFreedesktopNotificationsName,
+                                  "NotificationClosed", _, _))
+          .WillOnce(RegisterSignalCallback(&notification_closed_callback_));
+    }
+
+    EXPECT_CALL(*this, MockableNotificationBridgeReadyCallback(_))
+        .WillOnce(OnNotificationBridgeReady(expect_init_success));
+
+    if (expect_shutdown)
+      EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock());
+
     notification_bridge_linux_ =
         base::WrapUnique(new NotificationPlatformBridgeLinux(mock_bus_));
+    notification_bridge_linux_->SetReadyCallback(
+        base::BindOnce(&NotificationPlatformBridgeLinuxTest::
+                           MockableNotificationBridgeReadyCallback,
+                       base::Unretained(this)));
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
+  MOCK_METHOD1(MockableNotificationBridgeReadyCallback, void(bool));
+
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<dbus::MockBus> mock_bus_;
   scoped_refptr<dbus::MockObjectProxy> mock_notification_proxy_;
 
   base::Callback<void(dbus::Signal*)> action_invoked_callback_;
   base::Callback<void(dbus::Signal*)> notification_closed_callback_;
 
   std::unique_ptr<NotificationPlatformBridgeLinux> notification_bridge_linux_;
 
@@ skipping 139 matching lines @@
           1));
 
   CreateNotificationBridgeLinux();
   notification_bridge_linux_->Display(
       NotificationCommon::PERSISTENT, "", "", false,
       NotificationBuilder("")
           .SetMessage(base::ASCIIToUTF16("Body text"))
           .SetOriginUrl(GURL("https://google.com/search?q=test&ie=UTF8"))
           .GetResult());
 }
+
+TEST_F(NotificationPlatformBridgeLinuxTest, MissingActionsCapability) {
+  CreateNotificationBridgeLinux(std::vector<std::string>{"body"}, false, true,
+                                false);
+}
+
+TEST_F(NotificationPlatformBridgeLinuxTest, MissingBodyCapability) {
+  CreateNotificationBridgeLinux(std::vector<std::string>{"actions"}, false,
+                                true, false);
+}