From 277352c1051bca0b1bca266448947d04ac57c740 Mon Sep 17 00:00:00 2001
From: Charles Kerr <charles.kerr@canonical.com>
Date: Wed, 3 Feb 2016 12:28:10 -0600
Subject: add notification title, icon checks to test-notification's battery of
 test combinations

---
 tests/test-notification.cpp | 57 +++++++++++++++++++++++++++++++++------------
 1 file changed, 42 insertions(+), 15 deletions(-)

(limited to 'tests/test-notification.cpp')

diff --git a/tests/test-notification.cpp b/tests/test-notification.cpp
index c1773e4..5a2682e 100644
--- a/tests/test-notification.cpp
+++ b/tests/test-notification.cpp
@@ -58,11 +58,13 @@ TEST_F(NotificationFixture,Notification)
   // combinatorial factor #1: event type
   struct {
     Appointment appt;
+    const char* icon_name;
+    const char* prefix;
     bool expected_notify_called;
     bool expected_vibrate_called;
   } test_appts[] = {
-    { appt, true, true },
-    { ualarm, true, true }
+    { appt, "reminder", "Event", true, true },
+    { ualarm, "alarm-clock", "Alarm", true, true }
   };
 
   // combinatorial factor #2: indicator-datetime's haptic mode
@@ -90,11 +92,13 @@ TEST_F(NotificationFixture,Notification)
   const std::set<std::pair<std::string,std::string>> blacklist_empty;
   struct {
     std::set<std::pair<std::string,std::string>> muted_apps; // apps that should not trigger notifications
-    bool expected_notify_called; // do we expect the notification tho show?
-    bool expected_vibrate_called; // do we expect the phone to vibrate?
+    std::set<Appointment::Type> expected_notify_called; // do we expect the notification to show?
+    std::set<Appointment::Type> expected_vibrate_called; // do we expect the phone to vibrate?
   } test_muted_apps[] = {
-    { blacklist_calendar, false, false },
-    { blacklist_empty, true, true }
+    { blacklist_empty,    std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT },
+                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM, Appointment::Type::EVENT } },
+    { blacklist_calendar, std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM },
+                          std::set<Appointment::Type>{ Appointment::Type::UBUNTU_ALARM } }
   };
 
   for (const auto& test_appt : test_appts)
@@ -109,12 +113,12 @@ TEST_F(NotificationFixture,Notification)
 
     const bool expected_notify_called = test_appt.expected_notify_called
                                      && test_vibes.expected_notify_called
-                                     && test_muted.expected_notify_called
+                                     && (test_muted.expected_notify_called.count(test_appt.appt.type) > 0)
                                      && test_haptic.expected_notify_called;
 
     const bool expected_vibrate_called = test_appt.expected_vibrate_called
                                       && test_vibes.expected_vibrate_called
-                                      && test_muted.expected_vibrate_called
+                                      && (test_muted.expected_vibrate_called.count(test_appt.appt.type) > 0)
                                       && test_haptic.expected_vibrate_called;
 
     // clear out any previous iterations' noise
@@ -136,17 +140,40 @@ TEST_F(NotificationFixture,Notification)
     wait_msec(100);
 
     // run the test
-    (*snap)(appt, appt.alarms.front(), func, func);
+    (*snap)(test_appt.appt, appt.alarms.front(), func, func);
     wait_msec(100);
 
     // test that the notification was as expected
-    const bool notify_called = dbus_test_dbus_mock_object_check_method_call(notify_mock,
-                                                                            notify_obj,
-                                                                            METHOD_NOTIFY,
-                                                                            nullptr,
-                                                                            &error);
+    guint num_notify_calls = 0;
+    const auto notify_calls = dbus_test_dbus_mock_object_get_method_calls(notify_mock,
+                                                                          notify_obj,
+                                                                          METHOD_NOTIFY,
+                                                                          &num_notify_calls,
+                                                                          &error);
     g_assert_no_error(error);
-    EXPECT_EQ(expected_notify_called, notify_called);
+    EXPECT_EQ((expected_notify_called?1:0), num_notify_calls);
+    if (num_notify_calls > 0)
+    {
+        // test that Notify was called with the app_name
+        const gchar* app_name {nullptr};
+        g_variant_get_child(notify_calls[0].params, 0, "&s", &app_name);
+        ASSERT_STREQ(APP_NAME, app_name);
+
+        // test that Notify was called with the type-appropriate icon
+        const gchar* icon_name {nullptr};
+        g_variant_get_child(notify_calls[0].params, 2, "&s", &icon_name);
+        ASSERT_STREQ(test_appt.icon_name, icon_name);
+
+        // test that the Notification title has the correct prefix
+        const gchar* title {nullptr};
+        g_variant_get_child(notify_calls[0].params, 3, "&s", &title);
+        ASSERT_TRUE(g_str_has_prefix(title, test_appt.prefix));
+
+        // test that Notify was called with the appointment's body
+        const gchar* body {nullptr};
+        g_variant_get_child(notify_calls[0].params, 4, "&s", &body);
+        ASSERT_STREQ(test_appt.appt.summary.c_str(), body);
+    }
 
     // test that the vibration was as expected
     const bool vibrate_called = dbus_test_dbus_mock_object_check_method_call(haptic_mock,
-- 
cgit v1.2.3