Change the desktop menu's settings menuitem's label to match the spec. Fixes: 1296585

11 files changed, 494 insertions, 260 deletions

diff --git a/README b/README
index 6bd0edb..4202f16 100644
--- a/README
+++ b/README
@@ -1,18 +1,26 @@
 ACTIONS
 =======
 
- * "activate-settings"
-   Description: opens a page for changing indicator-datetime's settings
+ * "desktop.open-settings-app"
+ * "phone.open-settings-app"
+   Description: open the settings application.
    State: None
    Parameter: None
 
- * "activate-planner"
-   Description: opens an appointment editor.
+ * "desktop.open-alarm-app"
+ * "phone.open-alarm-app"
+   Description: open the application for creating new alarms.
+   State: None
+   Parameter: None
+
+ * "desktop.open-calendar-app"
+ * "phone.open-calendar-app"
    State: None
    Parameter: int64, a time_t hinting which day/time to show in the planner,
                      or 0 for the current day
 
- * "activate-appointment"
+ * "desktop.open-appointment"
+ * "phone.open-appointment"
    Description: opens an appointment editor to the specified appointment.
    State: None
    Parameter: string, an opaque uid to specify which appointment to use.
diff --git a/include/datetime/actions-live.h b/include/datetime/actions-live.h
index a24b844..0bf48a8 100644
--- a/include/datetime/actions-live.h
+++ b/include/datetime/actions-live.h
@@ -39,15 +39,18 @@ public:
     LiveActions(const std::shared_ptr<State>& state_in);
     ~LiveActions() =default;
 
-    void open_desktop_settings();
-    void open_phone_settings();
-    void open_phone_clock_app();
-    bool can_open_planner() const;
-    void open_planner();
-    void open_planner_at(const DateTime&);
-    void open_appointment(const std::string& uid);
+    bool desktop_has_calendar_app() const;
+    void desktop_open_alarm_app();
+    void desktop_open_appointment(const Appointment&);
+    void desktop_open_calendar_app(const DateTime&);
+    void desktop_open_settings_app();
+
+    void phone_open_alarm_app();
+    void phone_open_appointment(const Appointment&);
+    void phone_open_calendar_app(const DateTime&);
+    void phone_open_settings_app();
+
     void set_location(const std::string& zone, const std::string& name);
-    void set_calendar_date(const DateTime&);
 
 protected:
     virtual void execute_command(const std::string& command);
diff --git a/include/datetime/actions.h b/include/datetime/actions.h
index 2c4217c..f59ef67 100644
--- a/include/datetime/actions.h
+++ b/include/datetime/actions.h
@@ -42,14 +42,20 @@ namespace datetime {
 class Actions
 {
 public:
-    virtual void open_desktop_settings() =0;
-    virtual void open_phone_settings() =0;
-    virtual void open_phone_clock_app() =0;
-    virtual bool can_open_planner() const = 0;
-    virtual void open_planner() =0;
-    virtual void open_planner_at(const DateTime&) =0;
-    virtual void open_appointment(const std::string& uid) =0;
+
+    virtual bool desktop_has_calendar_app() const =0;
+    virtual void desktop_open_alarm_app() =0;
+    virtual void desktop_open_appointment(const Appointment&) =0;
+    virtual void desktop_open_calendar_app(const DateTime&) =0;
+    virtual void desktop_open_settings_app() =0;
+
+    virtual void phone_open_alarm_app() =0;
+    virtual void phone_open_appointment(const Appointment&) =0;
+    virtual void phone_open_calendar_app(const DateTime&) =0;
+    virtual void phone_open_settings_app() =0;
+
     virtual void set_location(const std::string& zone, const std::string& name)=0;
+
     void set_calendar_date(const DateTime&);
     GActionGroup* action_group();
     const std::shared_ptr<State> state() const;
diff --git a/src/actions-live.cpp b/src/actions-live.cpp
index 97b12db..068abe7 100644
--- a/src/actions-live.cpp
+++ b/src/actions-live.cpp
@@ -51,6 +51,7 @@ void LiveActions::execute_command(const std::string& cmdstr)
 
 void LiveActions::dispatch_url(const std::string& url)
 {
+    g_debug("Dispatching url '%s'", url.c_str());
     url_dispatch_send(url.c_str(), nullptr, nullptr);
 }
 
@@ -58,7 +59,7 @@ void LiveActions::dispatch_url(const std::string& url)
 ****
 ***/
 
-void LiveActions::open_desktop_settings()
+void LiveActions::desktop_open_settings_app()
 {
     auto path = g_find_program_in_path("unity-control-center");
 
@@ -74,7 +75,7 @@ void LiveActions::open_desktop_settings()
     g_free (path);
 }
 
-bool LiveActions::can_open_planner() const
+bool LiveActions::desktop_has_calendar_app() const
 {
     static bool inited = false;
     static bool have_calendar = false;
@@ -98,22 +99,17 @@ bool LiveActions::can_open_planner() const
     return have_calendar;
 }
 
-void LiveActions::open_planner()
+void LiveActions::desktop_open_alarm_app()
 {
     execute_command("evolution -c calendar");
 }
 
-void LiveActions::open_phone_settings()
+void LiveActions::desktop_open_appointment(const Appointment& appt)
 {
-    dispatch_url("settings:///system/time-date");
-}
-
-void LiveActions::open_phone_clock_app()
-{
-    dispatch_url("appid://com.ubuntu.clock/clock/current-user-version");
+    desktop_open_calendar_app(appt.begin);
 }
 
-void LiveActions::open_planner_at(const DateTime& dt)
+void LiveActions::desktop_open_calendar_app(const DateTime& dt)
 {
     const auto day_begins = dt.add_full(0, 0, 0, -dt.hour(), -dt.minute(), -dt.seconds());
     const auto gmt = day_begins.to_timezone("UTC");
@@ -121,17 +117,34 @@ void LiveActions::open_planner_at(const DateTime& dt)
     execute_command(cmd.c_str());
 }
 
-void LiveActions::open_appointment(const std::string& uid)
+/***
+****
+***/
+
+void LiveActions::phone_open_alarm_app()
 {
-    for(const auto& appt : state()->calendar_upcoming->appointments().get())
-    {
-        if(appt.uid != uid)
-            continue;
+    dispatch_url("appid://com.ubuntu.clock/clock/current-user-version");
+}
 
-        if (!appt.url.empty())
-            dispatch_url(appt.url);
-        break;
-    }
+void LiveActions::phone_open_appointment(const Appointment& appt)
+{
+    if (!appt.url.empty())
+        dispatch_url(appt.url);
+    else if (appt.has_alarms)
+        phone_open_alarm_app();
+    else
+        phone_open_calendar_app(DateTime::NowLocal());
+}
+
+void LiveActions::phone_open_calendar_app(const DateTime&)
+{
+    // does calendar app have a mechanism for specifying dates?
+    dispatch_url("appid://com.ubuntu.calendar/calendar/current-user-version");
+}
+
+void LiveActions::phone_open_settings_app()
+{
+    dispatch_url("settings:///system/time-date");
 }
 
 /***
diff --git a/src/actions.cpp b/src/actions.cpp
index 87adb96..1b665cc 100644
--- a/src/actions.cpp
+++ b/src/actions.cpp
@@ -34,67 +34,81 @@ namespace datetime {
 namespace
 {
 
-void on_desktop_settings_activated(GSimpleAction * /*action*/,
-                                   GVariant      * /*param*/,
-                                   gpointer        gself)
+DateTime datetime_from_timet_variant(GVariant* v)
 {
-    static_cast<Actions*>(gself)->open_desktop_settings();
-}
+    int64_t t = 0;
 
-void on_phone_settings_activated(GSimpleAction * /*action*/,
-                                 GVariant      * /*param*/,
-                                 gpointer        gself)
-{
-    static_cast<Actions*>(gself)->open_phone_settings();
-}
+    if (v != nullptr)
+        if (g_variant_type_equal(G_VARIANT_TYPE_INT64,g_variant_get_type(v)))
+            t = g_variant_get_int64(v);
 
-void on_phone_clock_activated(GSimpleAction * /*action*/,
-                              GVariant      * /*param*/,
-                              gpointer        gself)
-{
-    static_cast<Actions*>(gself)->open_phone_clock_app();
+    if (t != 0)
+        return DateTime(t);
+    else
+        return DateTime::NowLocal();
 }
 
-void on_activate_appointment(GSimpleAction * /*action*/,
-                             GVariant      * param,
-                             gpointer        gself)
+bool lookup_appointment_by_uid_variant(const std::shared_ptr<State>& state, GVariant* vuid, Appointment& setme)
 {
-    const auto uid = g_variant_get_string(param, nullptr);
-    auto self = static_cast<Actions*>(gself);
-
-    g_return_if_fail(uid && *uid);
+    g_return_val_if_fail(vuid != nullptr, false);
+    g_return_val_if_fail(g_variant_type_equal(G_VARIANT_TYPE_STRING,g_variant_get_type(vuid)), false);
+    const auto uid = g_variant_get_string(vuid, nullptr);
+    g_return_val_if_fail(uid && *uid, false);
 
-    // find url of the upcoming appointment with this uid
-    for (const auto& appt : self->state()->calendar_upcoming->appointments().get())
+    for(const auto& appt : state->calendar_upcoming->appointments().get())
     {
         if (appt.uid == uid)
         {
-            const auto url = appt.url;
-            g_debug("%s: uid[%s] -> url[%s]", G_STRFUNC, uid, url.c_str());
-            self->open_appointment(url);
-            break;
+            setme = appt;
+            return true;
         }
     }
+
+    return false;
 }
 
-void on_activate_planner(GSimpleAction * /*action*/,
-                         GVariant      * param,
-                         gpointer        gself)
+void on_desktop_appointment_activated (GSimpleAction*, GVariant *vuid, gpointer gself)
 {
-    const auto at = g_variant_get_int64(param);
     auto self = static_cast<Actions*>(gself);
+    Appointment appt;
+    if (lookup_appointment_by_uid_variant(self->state(), vuid, appt))
+        self->desktop_open_appointment(appt);
+}
+void on_desktop_alarm_activated (GSimpleAction*, GVariant*, gpointer gself)
+{
+    static_cast<Actions*>(gself)->desktop_open_alarm_app();
+}
+void on_desktop_calendar_activated (GSimpleAction*, GVariant* vt, gpointer gself)
+{
+    const auto dt = datetime_from_timet_variant(vt);
+    static_cast<Actions*>(gself)->desktop_open_calendar_app(dt);
+}
+void on_desktop_settings_activated (GSimpleAction*, GVariant*, gpointer gself)
+{
+    static_cast<Actions*>(gself)->desktop_open_settings_app();
+}
 
-    if (at)
-    {
-        auto gdt = g_date_time_new_from_unix_local(at);
-        self->open_planner_at(DateTime(gdt));
-        g_date_time_unref(gdt);
-    }
-    else // no time specified...
-    {
-        self->open_planner();
-    }
+void on_phone_appointment_activated (GSimpleAction*, GVariant *vuid, gpointer gself)
+{
+    auto self = static_cast<Actions*>(gself);
+    Appointment appt;
+    if (lookup_appointment_by_uid_variant(self->state(), vuid, appt))
+        self->phone_open_appointment(appt);
+}
+void on_phone_alarm_activated (GSimpleAction*, GVariant*, gpointer gself)
+{
+    static_cast<Actions*>(gself)->phone_open_alarm_app();
 }
+void on_phone_calendar_activated (GSimpleAction*, GVariant* vt, gpointer gself)
+{
+    const auto dt = datetime_from_timet_variant(vt);
+    static_cast<Actions*>(gself)->phone_open_calendar_app(dt);
+}
+void on_phone_settings_activated (GSimpleAction*, GVariant*, gpointer gself)
+{
+    static_cast<Actions*>(gself)->phone_open_settings_app();
+}
+
 
 void on_set_location(GSimpleAction * /*action*/,
                      GVariant      * param,
@@ -186,11 +200,17 @@ Actions::Actions(const std::shared_ptr<State>& state):
     m_actions(g_simple_action_group_new())
 {
     GActionEntry entries[] = {
-        { "activate-desktop-settings", on_desktop_settings_activated },
-        { "activate-phone-settings", on_phone_settings_activated },
-        { "activate-phone-clock-app", on_phone_clock_activated },
-        { "activate-appointment", on_activate_appointment, "s", nullptr },
-        { "activate-planner", on_activate_planner, "x", nullptr },
+
+        { "desktop.open-appointment",  on_desktop_appointment_activated, "s", nullptr },
+        { "desktop.open-alarm-app",    on_desktop_alarm_activated },
+        { "desktop.open-calendar-app", on_desktop_calendar_activated, "x", nullptr },
+        { "desktop.open-settings-app", on_desktop_settings_activated },
+
+        { "phone.open-appointment",    on_phone_appointment_activated, "s", nullptr },
+        { "phone.open-alarm-app",      on_phone_alarm_activated },
+        { "phone.open-calendar-app",   on_phone_calendar_activated, "x", nullptr },
+        { "phone.open-settings-app",   on_phone_settings_activated },
+
         { "calendar-active", nullptr, nullptr, "false", on_calendar_active_changed },
         { "set-location", on_set_location, "s" }
     };
diff --git a/src/menu.cpp b/src/menu.cpp
index 2bfc4aa..6cd1585 100644
--- a/src/menu.cpp
+++ b/src/menu.cpp
@@ -234,22 +234,28 @@ private:
 
     GMenuModel* create_calendar_section(Profile profile)
     {
-        const bool allow_activation = (profile == Desktop)
-                                   || (profile == Phone);
         const bool show_calendar = m_state->settings->show_calendar.get() &&
                                    ((profile == Desktop) || (profile == DesktopGreeter));
         auto menu = g_menu_new();
 
+        const char * action_name;
+
+        if (profile == Phone)
+            action_name = "indicator.phone.open-calendar-app";
+        else if (profile == Desktop)
+            action_name = "indicator.desktop.open-calendar-app";
+        else
+            action_name = nullptr;
+
         // add a menuitem that shows the current date
         auto label = m_state->clock->localtime().format(_("%A, %e %B %Y"));
         auto item = g_menu_item_new (label.c_str(), nullptr);
         auto v = get_serialized_calendar_icon();
         g_menu_item_set_attribute_value (item, G_MENU_ATTRIBUTE_ICON, v);
-        if (allow_activation)
+        if (action_name != nullptr)
         {
             v = g_variant_new_int64(0);
-            const char* action = "indicator.activate-planner";
-            g_menu_item_set_action_and_target_value (item, action, v);
+            g_menu_item_set_action_and_target_value (item, action_name, v);
         }
         g_menu_append_item(menu, item);
         g_object_unref(item);
@@ -262,11 +268,8 @@ private:
             g_menu_item_set_action_and_target_value (item, "indicator.calendar", v);
             g_menu_item_set_attribute (item, "x-canonical-type",
                                        "s", "com.canonical.indicator.calendar");
-            if (allow_activation)
-            {
-                g_menu_item_set_attribute (item, "activation-action",
-                                           "s", "indicator.activate-planner");
-            }
+            if (action_name != nullptr)
+                g_menu_item_set_attribute (item, "activation-action", "s", action_name);
             g_menu_append_item (menu, item);
             g_object_unref (item);
         }
@@ -279,6 +282,15 @@ private:
         const int MAX_APPTS = 5;
         std::set<std::string> added;
 
+        const char * action_name;
+
+        if (profile == Phone)
+            action_name = "indicator.phone.open-appointment";
+        else if ((profile == Desktop) && m_actions->desktop_has_calendar_app())
+            action_name = "indicator.desktop.open-appointment";
+        else
+            action_name = nullptr;
+
         for (const auto& appt : m_upcoming)
         {
             // don't show duplicates
@@ -312,15 +324,11 @@ private:
 
             if (!appt.color.empty())
                 g_menu_item_set_attribute (menu_item, "x-canonical-color", "s", appt.color.c_str());
-     
-            if (profile == Phone)
-                g_menu_item_set_action_and_target_value (menu_item,
-                                                     "indicator.activate-appointment",
-                                                     g_variant_new_string (appt.uid.c_str()));
-            else if (m_actions->can_open_planner())
-                g_menu_item_set_action_and_target_value (menu_item,
-                                                         "indicator.activate-planner",
-                                                         g_variant_new_int64 (unix_time));
+
+            if (action_name != nullptr)
+                g_menu_item_set_action_and_target_value (menu_item, action_name,
+                                                         g_variant_new_string (appt.uid.c_str()));
+
             g_menu_append_item (menu, menu_item);
             g_object_unref (menu_item);
         }
@@ -334,11 +342,11 @@ private:
         {
             add_appointments (menu, profile);
 
-            if (m_actions->can_open_planner())
+            if (m_actions->desktop_has_calendar_app())
             {
                 // add the 'Add Event…' menuitem
                 auto menu_item = g_menu_item_new(_("Add Event…"), nullptr);
-                const gchar* action_name = "indicator.activate-planner";
+                const gchar* action_name = "indicator.desktop.open-calendar-app";
                 auto v = g_variant_new_int64(0);
                 g_menu_item_set_action_and_target_value(menu_item, action_name, v);
                 g_menu_append_item(menu, menu_item);
@@ -347,7 +355,7 @@ private:
         }
         else if (profile==Phone)
         {
-            auto menu_item = g_menu_item_new (_("Clock"), "indicator.activate-phone-clock-app");
+            auto menu_item = g_menu_item_new (_("Clock"), "indicator.phone.open-alarm-app");
             g_menu_item_set_attribute_value (menu_item, G_MENU_ATTRIBUTE_ICON, get_serialized_alarm_icon());
             g_menu_append_item (menu, menu_item);
             g_object_unref (menu_item);
@@ -389,15 +397,17 @@ private:
     GMenuModel* create_settings_section(Profile profile)
     {
         auto menu = g_menu_new();
+        const char * action_name;
 
         if (profile == Desktop)
-        {
-            g_menu_append (menu, _("Date & Time Settings…"), "indicator.activate-desktop-settings");
-        }
+            action_name = "indicator.desktop.open-settings-app";
         else if (profile == Phone)
-        {
-            g_menu_append (menu, _("Time & Date settings…"), "indicator.activate-phone-settings");
-        }
+            action_name = "indicator.phone.open-settings-app";
+        else
+            action_name = nullptr;
+
+        if (action_name != nullptr)
+            g_menu_append (menu, _("Time & Date settings…"), action_name);
 
         return G_MENU_MODEL (menu);
     }
diff --git a/tests/actions-mock.h b/tests/actions-mock.h
index ebd8a4d..77315c0 100644
--- a/tests/actions-mock.h
+++ b/tests/actions-mock.h
@@ -34,28 +34,54 @@ public:
     MockActions(std::shared_ptr<State>& state_in): Actions(state_in) {}
     ~MockActions() =default;
 
-    enum Action { OpenDesktopSettings, OpenPhoneSettings, OpenPhoneClockApp,
-                  OpenPlanner, OpenPlannerAt, OpenAppointment, SetLocation };
+    enum Action { DesktopOpenAlarmApp,
+                  DesktopOpenAppt,
+                  DesktopOpenCalendarApp,
+                  DesktopOpenSettingsApp,
+                  PhoneOpenAlarmApp,
+                  PhoneOpenAppt,
+                  PhoneOpenCalendarApp,
+                  PhoneOpenSettingsApp,
+                  SetLocation };
+
     const std::vector<Action>& history() const { return m_history; }
     const DateTime& date_time() const { return m_date_time; }
     const std::string& zone() const { return m_zone; }
     const std::string& name() const { return m_name; }
-    const std::string& url() const { return m_url; }
+    const Appointment& appointment() const { return m_appt; }
     void clear() { m_history.clear(); m_zone.clear(); m_name.clear(); }
 
-    void open_desktop_settings() { m_history.push_back(OpenDesktopSettings); }
-
-    void open_phone_settings() { m_history.push_back(OpenPhoneSettings); }
-
-    void open_phone_clock_app() { m_history.push_back(OpenPhoneClockApp); }
-
-    bool can_open_planner() const { return m_can_open_planner; }
-
-    void open_planner() { m_history.push_back(OpenPlanner); }
+    bool desktop_has_calendar_app() const {
+        return m_desktop_has_calendar_app;
+    }
+    void desktop_open_alarm_app() {
+        m_history.push_back(DesktopOpenAlarmApp);
+    }
+    void desktop_open_appointment(const Appointment& appt) {
+        m_appt = appt;
+        m_history.push_back(DesktopOpenAppt);
+    }
+    void desktop_open_calendar_app(const DateTime& dt) {
+        m_date_time = dt;
+        m_history.push_back(DesktopOpenCalendarApp);
+    }
+    void desktop_open_settings_app() {
+        m_history.push_back(DesktopOpenSettingsApp);
+    }
 
-    void open_planner_at(const DateTime& date_time_) {
-        m_history.push_back(OpenPlannerAt);
-        m_date_time = date_time_;
+    void phone_open_alarm_app() {
+        m_history.push_back(PhoneOpenAlarmApp);
+    }
+    void phone_open_appointment(const Appointment& appt) {
+        m_appt = appt;
+        m_history.push_back(PhoneOpenAppt);
+    }
+    void phone_open_calendar_app(const DateTime& dt) {
+        m_date_time = dt;
+        m_history.push_back(PhoneOpenCalendarApp);
+    }
+    void phone_open_settings_app() {
+        m_history.push_back(PhoneOpenSettingsApp);
     }
 
     void set_location(const std::string& zone_, const std::string& name_) {
@@ -64,16 +90,13 @@ public:
         m_name = name_;
     }
 
-    void open_appointment(const std::string& url_) {
-        m_history.push_back(OpenAppointment);
-        m_url = url_;
+    void set_desktop_has_calendar_app(bool b) {
+        m_desktop_has_calendar_app = b;
     }
 
-    void set_can_open_planner(bool b) { m_can_open_planner = b; }
-
 private:
-    bool m_can_open_planner = true;
-    std::string m_url;
+    bool m_desktop_has_calendar_app = true;
+    Appointment m_appt;
     std::string m_zone;
     std::string m_name;
     DateTime m_date_time;
diff --git a/tests/test-actions.cpp b/tests/test-actions.cpp
index d838a52..9f7856c 100644
--- a/tests/test-actions.cpp
+++ b/tests/test-actions.cpp
@@ -23,7 +23,130 @@
 
 using namespace unity::indicator::datetime;
 
-typedef StateFixture ActionsFixture;
+class ActionsFixture: public StateFixture
+{
+    typedef StateFixture super;
+
+    std::vector<Appointment> build_some_appointments()
+    {
+        const auto now = m_state->clock->localtime();
+        auto gdt_tomorrow = g_date_time_add_days(now.get(), 1);
+        const auto tomorrow = DateTime(gdt_tomorrow);
+        g_date_time_unref(gdt_tomorrow);
+
+        Appointment a1; // an alarm clock appointment
+        a1.color = "red";
+        a1.summary = "Alarm";
+        a1.summary = "http://www.example.com/";
+        a1.uid = "example";
+        a1.has_alarms = true;
+        a1.begin = a1.end = tomorrow;
+
+        Appointment a2; // a non-alarm appointment
+        a2.color = "green";
+        a2.summary = "Other Text";
+        a2.summary = "http://www.monkey.com/";
+        a2.uid = "monkey";
+        a2.has_alarms = false;
+        a2.begin = a2.end = tomorrow;
+
+        return std::vector<Appointment>({a1, a2});
+    }
+
+protected:
+
+    virtual void SetUp()
+    {
+        super::SetUp();
+    }
+
+    virtual void TearDown()
+    {
+        super::TearDown();
+    }
+
+    void test_action_with_no_args(const char * action_name,
+                                  MockActions::Action expected_action)
+    {
+        // preconditions
+        EXPECT_TRUE(m_mock_actions->history().empty());
+        auto action_group = m_actions->action_group();
+        EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+
+        // run the test
+        g_action_group_activate_action(action_group, action_name, nullptr);
+
+        // test the results
+        EXPECT_EQ(std::vector<MockActions::Action>({expected_action}),
+                  m_mock_actions->history());
+    }
+
+    void test_action_with_time_arg(const char * action_name,
+                                   MockActions::Action expected_action)
+    {
+        // preconditions
+        EXPECT_TRUE(m_mock_actions->history().empty());
+        auto action_group = m_actions->action_group();
+        EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+
+        // activate the action
+        const auto now = DateTime::NowLocal();
+        auto v = g_variant_new_int64(now.to_unix());
+        g_action_group_activate_action(action_group, action_name, v);
+
+        // test the results
+        EXPECT_EQ(std::vector<MockActions::Action>({expected_action}),
+                  m_mock_actions->history());
+        EXPECT_EQ(now.format("%F %T"),
+                  m_mock_actions->date_time().format("%F %T"));
+    }
+
+    void test_action_with_appt_arg(const char * action_name,
+                                   MockActions::Action expected_action)
+    {
+        ///
+        ///  Test 1: activate an appointment that we know about
+        ///
+
+        // preconditions
+        EXPECT_TRUE(m_mock_actions->history().empty());
+        auto action_group = m_actions->action_group();
+        EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+
+        // init some appointments to the state
+        const auto appointments = build_some_appointments();
+        m_mock_state->mock_range_planner->appointments().set(appointments);
+
+        // activate the action
+        auto v = g_variant_new_string(appointments[0].uid.c_str());
+        g_action_group_activate_action(action_group, action_name, v);
+
+        // test the results
+        EXPECT_EQ(std::vector<MockActions::Action>({expected_action}),
+                  m_mock_actions->history());
+        EXPECT_EQ(appointments[0],
+                  m_mock_actions->appointment());
+
+        ///
+        ///  Test 2: activate an appointment we *don't* know about
+        ///
+
+        // setup
+        m_mock_actions->clear();
+        EXPECT_TRUE(m_mock_actions->history().empty());
+
+        // activate the action
+        v = g_variant_new_string("this-uid-is-not-one-that-we-have");
+        g_action_group_activate_action(action_group, action_name, v);
+
+        // test the results
+        EXPECT_TRUE(m_mock_actions->history().empty());
+    }
+};
+
+/***
+****
+***/
 
 TEST_F(ActionsFixture, ActionsExist)
 {
@@ -32,93 +155,81 @@ TEST_F(ActionsFixture, ActionsExist)
     const char* names[] = { "desktop-header",
                             "calendar",
                             "set-location",
-                            "activate-planner",
-                            "activate-appointment",
-                            "activate-phone-settings",
-                            "activate-phone-clock-app",
-                            "activate-desktop-settings" };
+                            "desktop.open-appointment",
+                            "desktop.open-alarm-app",
+                            "desktop.open-calendar-app",
+                            "desktop.open-settings-app",
+                            "phone.open-appointment",
+                            "phone.open-alarm-app",
+                            "phone.open-calendar-app",
+                            "phone.open-settings-app" };
+
     for(const auto& name: names)
     {
         EXPECT_TRUE(g_action_group_has_action(m_actions->action_group(), name));
     }
 }
 
-TEST_F(ActionsFixture, ActivateDesktopSettings)
-{
-    const auto action_name = "activate-desktop-settings";
-    const auto expected_action = MockActions::OpenDesktopSettings;
-
-    auto action_group = m_actions->action_group();
-    auto history = m_mock_actions->history();
-    EXPECT_EQ(0, history.size());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+/***
+****
+***/
 
-    g_action_group_activate_action(action_group, action_name, nullptr);
-    history = m_mock_actions->history();
-    EXPECT_EQ(1, history.size());
-    EXPECT_EQ(expected_action, history[0]);
+TEST_F(ActionsFixture, DesktopOpenAlarmApp)
+{
+    test_action_with_no_args("desktop.open-alarm-app",
+                             MockActions::DesktopOpenAlarmApp);
 }
 
-TEST_F(ActionsFixture, ActivatePhoneSettings)
+TEST_F(ActionsFixture, DesktopOpenAppointment)
 {
-    const auto action_name = "activate-phone-settings";
-    const auto expected_action = MockActions::OpenPhoneSettings;
-
-    auto action_group = m_actions->action_group();
-    EXPECT_TRUE(m_mock_actions->history().empty());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+    test_action_with_appt_arg("desktop.open-appointment",
+                              MockActions::DesktopOpenAppt);
+}
 
-    g_action_group_activate_action(action_group, action_name, nullptr);
-    auto history = m_mock_actions->history();
-    EXPECT_EQ(1, history.size());
-    EXPECT_EQ(expected_action, history[0]);
+TEST_F(ActionsFixture, DesktopOpenCalendarApp)
+{
+    test_action_with_time_arg("desktop.open-calendar-app",
+                              MockActions::DesktopOpenCalendarApp);
 }
 
-TEST_F(ActionsFixture, ActivatePhoneClockApp)
+TEST_F(ActionsFixture, DesktopOpenSettingsApp)
 {
-    const auto action_name = "activate-phone-clock-app";
-    const auto expected_action = MockActions::OpenPhoneClockApp;
+    test_action_with_no_args("desktop.open-settings-app",
+                             MockActions::DesktopOpenSettingsApp);
+}
 
-    auto action_group = m_actions->action_group();
-    EXPECT_TRUE(m_mock_actions->history().empty());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+/***
+****
+***/
 
-    g_action_group_activate_action(action_group, action_name, nullptr);
-    auto history = m_mock_actions->history();
-    EXPECT_EQ(1, history.size());
-    EXPECT_EQ(expected_action, history[0]);
+TEST_F(ActionsFixture, PhoneOpenAlarmApp)
+{
+    test_action_with_no_args("phone.open-alarm-app",
+                             MockActions::PhoneOpenAlarmApp);
 }
 
-TEST_F(ActionsFixture, ActivatePlanner)
+TEST_F(ActionsFixture, PhoneOpenAppointment)
 {
-    const auto action_name = "activate-planner";
-    auto action_group = m_actions->action_group();
-    EXPECT_TRUE(m_mock_actions->history().empty());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
-
-    const auto expected_action = MockActions::OpenPlanner;
-    auto v = g_variant_new_int64(0);
-    g_action_group_activate_action(action_group, action_name, v);
-    auto history = m_mock_actions->history();
-    EXPECT_EQ(1, history.size());
-    EXPECT_EQ(expected_action, history[0]);
+    test_action_with_appt_arg("phone.open-appointment",
+                              MockActions::PhoneOpenAppt);
 }
 
-TEST_F(ActionsFixture, ActivatePlannerAt)
+TEST_F(ActionsFixture, PhoneOpenCalendarApp)
 {
-    const auto action_name = "activate-planner";
-    auto action_group = m_actions->action_group();
-    EXPECT_TRUE(m_mock_actions->history().empty());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
+    test_action_with_time_arg("phone.open-calendar-app",
+                              MockActions::PhoneOpenCalendarApp);
+}
 
-    const auto now = DateTime::NowLocal();
-    auto v = g_variant_new_int64(now.to_unix());
-    g_action_group_activate_action(action_group, action_name, v);
-    const auto a = MockActions::OpenPlannerAt;
-    EXPECT_EQ(std::vector<MockActions::Action>({a}), m_mock_actions->history());
-    EXPECT_EQ(now.to_unix(), m_mock_actions->date_time().to_unix());
+TEST_F(ActionsFixture, PhoneOpenSettingsApp)
+{
+    test_action_with_no_args("phone.open-settings-app",
+                             MockActions::PhoneOpenSettingsApp);
 }
 
+/***
+****
+***/
+
 TEST_F(ActionsFixture, SetLocation)
 {
     const auto action_name = "set-location";
@@ -215,26 +326,3 @@ TEST_F(ActionsFixture, ActivatingTheCalendarResetsItsDate)
     g_clear_pointer(&calendar_state, g_variant_unref);
 
 }
-
-
-TEST_F(ActionsFixture, OpenAppointment)
-{
-    Appointment appt;
-    appt.uid = "some arbitrary uid";
-    appt.url = "http://www.canonical.com/";
-    appt.begin = m_state->clock->localtime();
-    m_state->calendar_upcoming->appointments().set(std::vector<Appointment>({appt}));
-
-    const auto action_name = "activate-appointment";
-    auto action_group = m_actions->action_group();
-    EXPECT_TRUE(m_mock_actions->history().empty());
-    EXPECT_TRUE(g_action_group_has_action(action_group, action_name));
-
-    auto v = g_variant_new_string(appt.uid.c_str());
-    g_action_group_activate_action(action_group, action_name, v);
-    const auto a = MockActions::OpenAppointment;
-    ASSERT_EQ(1, m_mock_actions->history().size());
-    ASSERT_EQ(a, m_mock_actions->history()[0]);
-    EXPECT_EQ(appt.url, m_mock_actions->url());
-}
-
diff --git a/tests/test-exporter.cpp b/tests/test-exporter.cpp
index 104fb4b..a255ef9 100644
--- a/tests/test-exporter.cpp
+++ b/tests/test-exporter.cpp
@@ -104,11 +104,14 @@ TEST_F(ExporterFixture, Publish)
       names.insert(names_strv[i]);
 
     // confirm the actions that we expect
-    EXPECT_EQ(1, names.count("activate-appointment"));
-    EXPECT_EQ(1, names.count("activate-desktop-settings"));
-    EXPECT_EQ(1, names.count("activate-phone-clock-app"));
-    EXPECT_EQ(1, names.count("activate-phone-settings"));
-    EXPECT_EQ(1, names.count("activate-planner"));
+    EXPECT_EQ(1, names.count("desktop.open-alarm-app"));
+    EXPECT_EQ(1, names.count("desktop.open-appointment"));
+    EXPECT_EQ(1, names.count("desktop.open-calendar-app"));
+    EXPECT_EQ(1, names.count("desktop.open-settings-app"));
+    EXPECT_EQ(1, names.count("phone.open-alarm-app"));
+    EXPECT_EQ(1, names.count("phone.open-appointment"));
+    EXPECT_EQ(1, names.count("phone.open-calendar-app"));
+    EXPECT_EQ(1, names.count("phone.open-settings-app"));
     EXPECT_EQ(1, names.count("calendar"));
     EXPECT_EQ(1, names.count("desktop_greeter-header"));
     EXPECT_EQ(1, names.count("desktop-header"));
diff --git a/tests/test-live-actions.cpp b/tests/test-live-actions.cpp
index d6ef424..c67b380 100644
--- a/tests/test-live-actions.cpp
+++ b/tests/test-live-actions.cpp
@@ -252,44 +252,95 @@ TEST_F(LiveActionsFixture, SetLocation)
     EXPECT_EQ(expected, m_state->settings->timezone_name.get());
 }
 
-TEST_F(LiveActionsFixture, OpenDesktopSettings)
+/***
+****
+***/
+
+TEST_F(LiveActionsFixture, DesktopOpenAlarmApp)
+{
+    m_actions->desktop_open_alarm_app();
+    const std::string expected = "evolution -c calendar";
+    EXPECT_EQ(expected, m_live_actions->last_cmd);
+}
+
+TEST_F(LiveActionsFixture, DesktopOpenAppointment)
+{
+    Appointment a;
+    a.uid = "some-uid";
+    a.begin = DateTime::NowLocal();
+    m_actions->desktop_open_appointment(a);
+    const std::string expected_substr = "evolution \"calendar:///?startdate=";
+    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
+}
+
+TEST_F(LiveActionsFixture, DesktopOpenCalendarApp)
+{
+    m_actions->desktop_open_calendar_app(DateTime::NowLocal());
+    const std::string expected_substr = "evolution \"calendar:///?startdate=";
+    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
+}
+
+TEST_F(LiveActionsFixture, DesktopOpenSettingsApp)
 {
-    m_actions->open_desktop_settings();
+    m_actions->desktop_open_settings_app();
     const std::string expected_substr = "control-center";
     EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
 }
 
-TEST_F(LiveActionsFixture, OpenPlanner)
+/***
+****
+***/
+
+namespace
 {
-    m_actions->open_planner();
-    const std::string expected = "evolution -c calendar";
-    EXPECT_EQ(expected, m_live_actions->last_cmd);
+    const std::string clock_app_url = "appid://com.ubuntu.clock/clock/current-user-version";
+
+    const std::string calendar_app_url = "appid://com.ubuntu.calendar/calendar/current-user-version";
 }
 
-TEST_F(LiveActionsFixture, OpenPhoneSettings)
+TEST_F(LiveActionsFixture, PhoneOpenAlarmApp)
 {
-    m_actions->open_phone_settings();
-    const std::string expected = "settings:///system/time-date";
-    EXPECT_EQ(expected, m_live_actions->last_url);
+    m_actions->phone_open_alarm_app();
+    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
 }
 
-TEST_F(LiveActionsFixture, OpenPhoneClockApp)
+TEST_F(LiveActionsFixture, PhoneOpenAppointment)
 {
-    m_actions->open_phone_clock_app();
-    const std::string expected = "appid://com.ubuntu.clock/clock/current-user-version";
+    Appointment a;
+
+    a.uid = "some-uid";
+    a.begin = DateTime::NowLocal();
+    a.has_alarms = false;
+    m_actions->phone_open_appointment(a);
+    EXPECT_EQ(calendar_app_url, m_live_actions->last_url);
+
+    a.has_alarms = true;
+    m_actions->phone_open_appointment(a);
+    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
+
+    a.url = "appid://blah";
+    m_actions->phone_open_appointment(a);
+    EXPECT_EQ(a.url, m_live_actions->last_url);
+}
+
+TEST_F(LiveActionsFixture, PhoneOpenCalendarApp)
+{
+    m_actions->phone_open_calendar_app(DateTime::NowLocal());
+    const std::string expected = "appid://com.ubuntu.calendar/calendar/current-user-version";
     EXPECT_EQ(expected, m_live_actions->last_url);
 }
 
-TEST_F(LiveActionsFixture, OpenPlannerAt)
+TEST_F(LiveActionsFixture, PhoneOpenSettingsApp)
 {
-    const auto now = DateTime::NowLocal();
-    m_actions->open_planner_at(now);
-    const auto today_begins = now.add_full(0, 0, 0, -now.hour(), -now.minute(), -now.seconds());
-    const auto gmt = today_begins.to_timezone("UTC");
-    const auto expected = gmt.format("evolution \"calendar:///?startdate=%Y%m%dT%H%M%SZ\"");
-    EXPECT_EQ(expected, m_live_actions->last_cmd);
+    m_actions->phone_open_settings_app();
+    const std::string expected = "settings:///system/time-date";
+    EXPECT_EQ(expected, m_live_actions->last_url);
 }
 
+/***
+****
+***/
+
 TEST_F(LiveActionsFixture, CalendarState)
 {
     // init the clock
diff --git a/tests/test-menus.cpp b/tests/test-menus.cpp
index 29d86b3..b485037 100644
--- a/tests/test-menus.cpp
+++ b/tests/test-menus.cpp
@@ -92,7 +92,16 @@ protected:
     void InspectCalendar(GMenuModel* menu_model, Menu::Profile profile)
     {
         gchar* str = nullptr;
-        const auto actions_expected = (profile == Menu::Desktop) || (profile == Menu::Phone);
+
+        const char * expected_action;
+
+        if (profile == Menu::Desktop)
+            expected_action = "indicator.desktop.open-calendar-app";
+        else if (profile == Menu::Phone)
+            expected_action = "indicator.phone.open-calendar-app";
+        else
+            expected_action = nullptr;
+
         const auto calendar_expected = ((profile == Menu::Desktop) || (profile == Menu::DesktopGreeter))
                                     && (m_state->settings->show_calendar.get());
 
@@ -113,8 +122,8 @@ protected:
         g_clear_pointer(&str, g_free);
 
         g_menu_model_get_item_attribute(section, 0, G_MENU_ATTRIBUTE_ACTION, "s", &str);
-        if (actions_expected)
-            EXPECT_STREQ("indicator.activate-planner", str);
+        if (expected_action != nullptr)
+            EXPECT_STREQ(expected_action, str);
         else
             EXPECT_TRUE(str == nullptr);
         g_clear_pointer(&str, g_free);
@@ -131,8 +140,8 @@ protected:
             g_clear_pointer(&str, g_free);
 
             g_menu_model_get_item_attribute(section, 1, "activation-action", "s", &str);
-            if (actions_expected)
-                EXPECT_STREQ("indicator.activate-planner", str);
+            if (expected_action != nullptr)
+                EXPECT_STREQ(expected_action, str);
             else
                 EXPECT_TRUE(str == nullptr);
             g_clear_pointer(&str, g_free);
@@ -297,7 +306,7 @@ private:
             // there should be an "add event" button even if there aren't any appointments
             gchar* action = nullptr;
             EXPECT_TRUE(g_menu_model_get_item_attribute(section, 0, G_MENU_ATTRIBUTE_ACTION, "s", &action));
-            const char* expected_action = "activate-planner";
+            const char* expected_action = "desktop.open-calendar-app";
             EXPECT_EQ(std::string("indicator.")+expected_action, action);
             EXPECT_TRUE(g_action_group_has_action(m_actions->action_group(), expected_action));
             g_free(action);
@@ -328,7 +337,7 @@ private:
 
         // check that there's a "clock app" menuitem even when there are no appointments
         auto section = g_menu_model_get_item_link(submenu, Menu::Appointments, G_MENU_LINK_SECTION);
-        const char* expected_action = "activate-phone-clock-app";
+        const char* expected_action = "phone.open-alarm-app";
         EXPECT_EQ(1, g_menu_model_get_n_items(section));
         gchar* action = nullptr;
         EXPECT_TRUE(g_menu_model_get_item_attribute(section, 0, G_MENU_ATTRIBUTE_ACTION, "s", &action));
@@ -354,7 +363,7 @@ protected:
 
     void InspectAppointments(GMenuModel* menu_model, Menu::Profile profile)
     {
-        const auto can_open_planner = m_actions->can_open_planner();
+        const auto can_open_planner = m_actions->desktop_has_calendar_app();
 
         switch (profile)
         {
@@ -443,9 +452,9 @@ protected:
         std::string expected_action;
 
         if (profile == Menu::Desktop)
-            expected_action = "indicator.activate-desktop-settings";
+            expected_action = "indicator.desktop.open-settings-app";
         else if (profile == Menu::Phone)
-            expected_action = "indicator.activate-phone-settings";
+            expected_action = "indicator.phone.open-settings-app";
 
         // get the Settings section
         auto submenu = g_menu_model_get_item_link(menu_model, 0, G_MENU_LINK_SUBMENU);
@@ -520,7 +529,7 @@ TEST_F(MenuFixture, Appointments)
     // toggle can_open_planner() and test the desktop again
     // to confirm that the "Add Event…" menuitem appears iff
     // there's a calendar available user-agent
-    m_mock_actions->set_can_open_planner (!m_actions->can_open_planner());
+    m_mock_actions->set_desktop_has_calendar_app (!m_actions->desktop_has_calendar_app());
     std::shared_ptr<Menu> menu = m_menu_factory->buildMenu(Menu::Desktop);
     InspectAppointments(menu->menu_model(), menu->profile());
 }