Merge lp:~renatofilho/indicator-datetime/fix-1508438-2 into lp:indicator-datetime/15.10

[Renato Araujo Oliveira Filho]

test

Unmerged revisions

449. By Renato Araujo Oliveira Filho on 2016-04-05

Attempt to fix.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-02-03 16:33:39 +0000
+++ CMakeLists.txt	2016-04-05 20:43:14 +0000
@@ -20,7 +20,7 @@
 
 ##
 ##  GNU standard installation directories
-## 
+##
 
 include (GNUInstallDirs)
 if (EXISTS "/etc/debian_version") # Workaround for libexecdir on debian
@@ -47,7 +47,8 @@
                    gstreamer-1.0>=1.2
                    libnotify>=0.7.6
                    url-dispatcher-1>=1
-                   properties-cpp>=0.0.1)
+                   properties-cpp>=0.0.1
+                   libaccounts-glib>=1.21)
 include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 ##

=== modified file 'debian/control'
--- debian/control	2016-03-10 16:20:36 +0000
+++ debian/control	2016-04-05 20:43:14 +0000
@@ -29,6 +29,8 @@
                gvfs-daemons,
 # for phone alarm/calendar notification sound tests:
                ubuntu-touch-sounds,
+# for query user e-mails based on accounts
+               libaccounts-glib-dev,
 Standards-Version: 3.9.3
 Homepage: https://launchpad.net/indicator-datetime
 # If you aren't a member of ~indicator-applet-developers but need to upload

=== modified file 'include/datetime/engine-eds.h'
--- include/datetime/engine-eds.h	2014-12-08 02:52:50 +0000
+++ include/datetime/engine-eds.h	2016-04-05 20:43:14 +0000
@@ -36,16 +36,17 @@
 /****
 *****
 ****/
+class Myself;
 
 /**
  * Class wrapper around EDS so multiple #EdsPlanners can share resources
- * 
+ *
  * @see EdsPlanner
  */
 class EdsEngine: public Engine
 {
 public:
-    EdsEngine();
+    EdsEngine(const std::shared_ptr<Myself> &myself);
     ~EdsEngine();
 
     void get_appointments(const DateTime& begin,

=== added file 'include/datetime/myself.h'
--- include/datetime/myself.h	1970-01-01 00:00:00 +0000
+++ include/datetime/myself.h	2016-04-05 20:43:14 +0000
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Renato Araujo Oliveira Filho <[e-mail]>
+ */
+
+#ifndef INDICATOR_DATETIME_MYSELF_H
+#define INDICATOR_DATETIME_MYSELF_H
+
+#include <core/property.h>
+
+#include <string>
+#include <set>
+#include <memory.h>
+#include <glib.h>
+
+typedef struct _AgManager AgManager;
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+class Myself
+{
+public:
+     Myself();
+
+     const core::Property<std::set<std::string>>& emails()
+     {
+         return m_emails;
+     }
+
+     bool isMyEmail(const std::string &email);
+
+private:
+     std::shared_ptr<AgManager> m_accounts_manager;
+     core::Property<std::set<std::string> > m_emails;
+
+     static void on_accounts_changed(AgManager*, guint, Myself*);
+     void reloadEmails();
+
+};
+
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+
+#endif // INDICATOR_DATETIME_MYSELF_H

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-09-01 09:52:13 +0000
+++ src/CMakeLists.txt	2016-04-05 20:43:14 +0000
@@ -23,6 +23,7 @@
      locations.cpp
      locations-settings.cpp
      menu.cpp
+     myself.cpp
      notifications.cpp
      planner.cpp
      planner-aggregate.cpp

=== modified file 'src/engine-eds.cpp'
--- src/engine-eds.cpp	2016-03-22 19:32:25 +0000
+++ src/engine-eds.cpp	2016-04-05 20:43:14 +0000
@@ -18,6 +18,7 @@
  */
 
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 
 #include <libical/ical.h>
 #include <libical/icaltime.h>
@@ -48,7 +49,8 @@
 {
 public:
 
-    Impl()
+    Impl(const std::shared_ptr<Myself> &myself)
+        : m_myself(myself)
     {
         auto cancellable_deleter = [](GCancellable * c) {
             g_cancellable_cancel(c);
@@ -56,8 +58,10 @@
         };
 
         m_cancellable = std::shared_ptr<GCancellable>(g_cancellable_new(), cancellable_deleter);
-
         e_source_registry_new(m_cancellable.get(), on_source_registry_ready, this);
+        m_myself->emails().changed().connect([this](const std::set<std::string> &) {
+            set_dirty_soon();
+        });
     }
 
     ~Impl()
@@ -125,35 +129,14 @@
             auto extension = e_source_get_extension(source, E_SOURCE_EXTENSION_CALENDAR);
             const auto color = e_source_selectable_get_color(E_SOURCE_SELECTABLE(extension));
 
-            auto begin_str = isodate_from_time_t(begin.to_unix());
-            auto end_str = isodate_from_time_t(end.to_unix());
-            auto sexp_fmt = g_strdup_printf("(%%s? (make-time \"%s\") (make-time \"%s\"))", begin_str, end_str);
-            g_clear_pointer(&begin_str, g_free);
-            g_clear_pointer(&end_str, g_free);
-
-            // ask EDS about alarms that occur in this window...
-            auto sexp = g_strdup_printf(sexp_fmt, "has-alarms-in-range");
-            g_debug("%s alarm sexp is %s", G_STRLOC, sexp);
-            e_cal_client_get_object_list_as_comps(
-                client,
-                sexp,
-                m_cancellable.get(),
-                on_alarm_component_list_ready,
-                new ClientSubtask(main_task, client, m_cancellable, color));
-            g_clear_pointer(&sexp, g_free);
-
-            // ask EDS about events that occur in this window...
-            sexp = g_strdup_printf(sexp_fmt, "occur-in-time-range");
-            g_debug("%s event sexp is %s", G_STRLOC, sexp);
-            e_cal_client_get_object_list_as_comps(
-                client,
-                sexp,
-                m_cancellable.get(),
-                on_event_component_list_ready,
-                new ClientSubtask(main_task, client, m_cancellable, color));
-            g_clear_pointer(&sexp, g_free);
-
-            g_clear_pointer(&sexp_fmt, g_free);
+            e_cal_client_generate_instances(
+                client,
+                begin.to_unix(),
+                end.to_unix(),
+                m_cancellable.get(),
+                on_event_generated,
+                new ClientSubtask(main_task, client, m_cancellable, color),
+                on_event_generated_list_ready);
         }
     }
 
@@ -591,6 +574,8 @@
         ECalClient* client;
         std::shared_ptr<GCancellable> cancellable;
         std::string color;
+        GList *components;
+        GList *global_components;
 
         ClientSubtask(const std::shared_ptr<Task>& task_in,
                       ECalClient* client_in,
@@ -598,10 +583,13 @@
                       const char* color_in):
             task(task_in),
             client(client_in),
-            cancellable(cancellable_in)
+            cancellable(cancellable_in),
+            components(nullptr),
+            global_components(nullptr)
         {
             if (color_in)
                 color = color_in;
+
         }
     };
 
@@ -648,77 +636,109 @@
         return ret;
     }
 
+    static gboolean
+    on_event_generated(ECalComponent *comp,
+                       time_t,
+                       time_t,
+                       gpointer gsubtask)
+    {
+        auto subtask = static_cast<ClientSubtask*>(gsubtask);
+        const gchar *uid = nullptr;
+        e_cal_component_get_uid (comp, &uid);
+        g_debug("COMP (%p):%s", (void*) comp, uid);
+        g_object_ref(comp);
+        subtask->components = g_list_append(subtask->components, comp);
+        return TRUE;
+    }
+
     static void
-    on_alarm_component_list_ready(GObject      * oclient,
-                                  GAsyncResult * res,
-                                  gpointer       gsubtask)
+    on_event_generated_list_ready(gpointer gsubtask)
     {
-        GError * error = NULL;
-        GSList * comps_slist = NULL;
         auto subtask = static_cast<ClientSubtask*>(gsubtask);
-
-        if (e_cal_client_get_object_list_as_comps_finish(E_CAL_CLIENT(oclient),
-                                                         res,
-                                                         &comps_slist,
-                                                         &error))
+        if (g_list_length(subtask->components) > 0) {
+            auto l = g_list_first(subtask->components);
+            ECalComponent *comp = static_cast<ECalComponent*>(l->data);
+            subtask->components = g_list_remove_link(subtask->components, l);
+
+            bool has_recurrence = e_cal_component_has_recurrences(comp);
+            subtask->global_components = g_list_append(subtask->global_components, comp);
+
+            if (has_recurrence)
+            {
+                const gchar *uid = nullptr;
+                e_cal_component_get_uid(comp, &uid);
+
+                g_debug(" GET COMPONENTS FOR UID: (%p): %s", comp, uid);
+                e_cal_client_get_objects_for_uid(subtask->client,
+                                                 uid,
+                                                 subtask->cancellable.get(),
+                                                 on_event_retrieved,
+                                                 gsubtask);
+            }
+            else
+            {
+                on_event_generated_list_ready(gsubtask);
+            }
+        }
+        else
         {
-            // _generate_alarms takes a GList, so make a shallow one
-            GList * comps_list = nullptr;
-            for (auto l=comps_slist; l!=nullptr; l=l->next)
-                comps_list = g_list_prepend(comps_list, l->data);
-
+            // generate alarms
             constexpr std::array<ECalComponentAlarmAction,1> omit = {
                 (ECalComponentAlarmAction)-1
             }; // list of action types to omit, terminated with -1
             GSList * comp_alarms = nullptr;
             e_cal_util_generate_alarms_for_list(
-                comps_list,
+                subtask->global_components,
                 subtask->task->begin.to_unix(),
                 subtask->task->end.to_unix(),
                 const_cast<ECalComponentAlarmAction*>(omit.data()),
                 &comp_alarms,
                 e_cal_client_resolve_tzid_cb,
-                oclient,
+                subtask->client,
                 subtask->task->default_timezone);
 
             // walk the alarms & add them
             for (auto l=comp_alarms; l!=nullptr; l=l->next)
                 add_alarms_to_subtask(static_cast<ECalComponentAlarms*>(l->data), subtask, subtask->task->gtz);
 
-            // cleanup
-            e_cal_free_alarms(comp_alarms);
-            g_list_free(comps_list);
-            e_cal_client_free_ecalcomp_slist(comps_slist);
-        }
-        else if (error != nullptr)
-        {
-            if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-                g_warning("can't get ecalcomponent list: %s", error->message);
-
-            g_error_free(error);
-        }
-
-        delete subtask;
+
+            // add events
+            for (auto l=subtask->global_components; l!=nullptr; l=l->next) {
+                auto component = static_cast<ECalComponent*>(l->data);
+                if (!e_cal_component_has_alarms(component))
+                    add_event_to_subtask(static_cast<ECalComponent*>(l->data), subtask, subtask->task->gtz);
+            }
+
+            g_list_free_full(subtask->global_components, g_object_unref);
+
+            g_debug("QUERY EMPTY DONE>>>>>>>>>>>>>");
+            delete subtask;
+        }
     }
 
     static void
-    on_event_component_list_ready(GObject      * oclient,
-                                  GAsyncResult * res,
-                                  gpointer       gsubtask)
+    on_event_retrieved (GObject *,
+                        GAsyncResult * res,
+                        gpointer gsubtask)
     {
-        GError * error = NULL;
-        GSList * comps_slist = NULL;
+        GError * error = nullptr;
+        GSList * comps_slist = nullptr;
         auto subtask = static_cast<ClientSubtask*>(gsubtask);
 
-        if (e_cal_client_get_object_list_as_comps_finish(E_CAL_CLIENT(oclient),
-                                                         res,
-                                                         &comps_slist,
-                                                         &error))
+        if (e_cal_client_get_objects_for_uid_finish(subtask->client,
+                                                    res,
+                                                    &comps_slist,
+                                                    &error))
         {
+            g_debug("LIST::::::::::::::%d", g_slist_length(comps_slist));
             for (auto l=comps_slist; l!=nullptr; l=l->next)
-                add_event_to_subtask(static_cast<ECalComponent*>(l->data), subtask, subtask->task->gtz);
-
+            {
+                auto comp = static_cast<ECalComponent*>(l->data);
+                g_object_ref(comp);
+                subtask->global_components = g_list_append(subtask->global_components, comp);
+            }
             e_cal_client_free_ecalcomp_slist(comps_slist);
+
         }
         else if (error != nullptr)
         {
@@ -728,9 +748,10 @@
             g_error_free(error);
         }
 
-        delete subtask;
+        on_event_generated_list_ready (gsubtask);
     }
 
+
     static DateTime
     datetime_from_component_date_time(ECalClient                     * client,
                                       std::shared_ptr<GCancellable>  & cancellable,
@@ -797,7 +818,7 @@
         return out;
     }
 
-    static bool
+    bool
     is_component_interesting(ECalComponent * component)
     {
         // we only want calendar events and vtodos
@@ -823,6 +844,28 @@
                 disabled = true;
         }
         e_cal_component_free_categories_list(categ_list);
+
+        if (!disabled) {
+            // we don't want not attending alarms
+            // check if the user is part of attendee list if we found it check the status
+            GSList *attendeeList = nullptr;
+            e_cal_component_get_attendee_list(component, &attendeeList);
+
+            for (GSList *attendeeIter=attendeeList; attendeeIter != nullptr; attendeeIter = attendeeIter->next) {
+                ECalComponentAttendee *attendee = static_cast<ECalComponentAttendee *>(attendeeIter->data);
+                if (attendee->value) {
+                    if (strncmp(attendee->value, "mailto:", 7) == 0) {
+                        if (m_myself->isMyEmail(attendee->value+7)) {
+                            disabled = (attendee->status == ICAL_PARTSTAT_DECLINED);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (attendeeList)
+                e_cal_component_free_attendee_list(attendeeList);
+        }
+
         if (disabled)
             return false;
 
@@ -903,35 +946,13 @@
     }
 
     static void
-    add_event_to_subtask(ECalComponent * component,
-                         ClientSubtask * subtask,
-                         GTimeZone     * gtz)
-    {
-        // events with alarms are covered by add_alarms_to_subtask(),
-        // so skip them here
-        auto auids = e_cal_component_get_alarm_uids(component);
-        const bool has_alarms = auids != nullptr;
-        cal_obj_uid_list_free(auids);
-        if (has_alarms)
-            return;
-
-        // add it. simple, eh?
-        if (is_component_interesting(component))
-        {
-            Appointment appointment = get_appointment(subtask->client, subtask->cancellable, component, gtz);
-            appointment.color = subtask->color;
-            subtask->task->appointments.push_back(appointment);
-        }
-    }
-
-    static void
     add_alarms_to_subtask(ECalComponentAlarms * comp_alarms,
                           ClientSubtask       * subtask,
                           GTimeZone           * gtz)
     {
         auto& component = comp_alarms->comp;
 
-        if (!is_component_interesting(component))
+        if (!subtask->task->p->is_component_interesting(component))
             return;
 
         Appointment baseline = get_appointment(subtask->client, subtask->cancellable, component, gtz);
@@ -990,6 +1011,22 @@
         }
     }
 
+    static void
+    add_event_to_subtask(ECalComponent * component,
+                         ClientSubtask * subtask,
+                         GTimeZone     * gtz)
+    {
+        // add it. simple, eh?
+        if (subtask->task->p->is_component_interesting(component))
+        {
+            Appointment appointment = get_appointment(subtask->client, subtask->cancellable, component, gtz);
+            appointment.color = subtask->color;
+            subtask->task->appointments.push_back(appointment);
+        } else {
+            g_debug("EVENT NOT INTERESTING: (%p)", component);
+        }
+    }
+
     /***
     ****
     ***/
@@ -1062,14 +1099,15 @@
     ESourceRegistry* m_source_registry {};
     guint m_rebuild_tag {};
     time_t m_rebuild_deadline {};
+    std::shared_ptr<Myself> m_myself;
 };
 
 /***
 ****
 ***/
 
-EdsEngine::EdsEngine():
-    p(new Impl())
+EdsEngine::EdsEngine(const std::shared_ptr<Myself> &myself):
+    p(new Impl(myself))
 {
 }
 

=== modified file 'src/main.cpp'
--- src/main.cpp	2015-10-13 16:06:35 +0000
+++ src/main.cpp	2016-04-05 20:43:14 +0000
@@ -25,6 +25,7 @@
 #include <datetime/exporter.h>
 #include <datetime/locations-settings.h>
 #include <datetime/menu.h>
+#include <datetime/myself.h>
 #include <datetime/planner-aggregate.h>
 #include <datetime/planner-snooze.h>
 #include <datetime/planner-range.h>
@@ -58,7 +59,7 @@
         if (!g_strcmp0("lightdm", g_get_user_name()))
             engine.reset(new MockEngine);
         else
-            engine.reset(new EdsEngine);
+            engine.reset(new EdsEngine(std::shared_ptr<Myself>(new Myself)));
 
         return engine;
     }

=== added file 'src/myself.cpp'
--- src/myself.cpp	1970-01-01 00:00:00 +0000
+++ src/myself.cpp	2016-04-05 20:43:14 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Renato Araujo Oliveira Filho <[e-mail]>
+ */
+
+#include "datetime/myself.h"
+
+#include <libaccounts-glib/ag-manager.h>
+#include <libaccounts-glib/ag-account.h>
+
+#include <algorithm>
+
+namespace unity {
+namespace indicator {
+namespace datetime {
+
+Myself::Myself()
+    : m_accounts_manager(ag_manager_new(), g_object_unref)
+{
+    reloadEmails();
+    g_object_connect(m_accounts_manager.get(),
+                     "signal::account-created", on_accounts_changed, this,
+                     "signal::account-deleted", on_accounts_changed, this,
+                     "signal::account-updated", on_accounts_changed, this,
+                     nullptr);
+}
+
+bool Myself::isMyEmail(const std::string &email)
+{
+    return m_emails.get().count(email) > 0;
+}
+
+void Myself::on_accounts_changed(AgManager *, guint, Myself *self)
+{
+    self->reloadEmails();
+}
+
+void Myself::reloadEmails()
+{
+    std::set<std::string> emails;
+
+    auto manager = m_accounts_manager.get();
+    auto ids = ag_manager_list(manager);
+    for (auto l=ids; l!=nullptr; l=l->next)
+    {
+        auto acc = ag_manager_get_account(manager, GPOINTER_TO_UINT(l->data));
+        if (acc) {
+            auto account_name = ag_account_get_display_name(acc);
+            if (account_name != nullptr)
+                emails.insert(account_name);
+            g_object_unref(acc);
+        }
+    }
+    ag_manager_list_free(ids);
+
+    m_emails.set(emails);
+}
+
+} // namespace datetime
+} // namespace indicator
+} // namespace unity
+

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-03-22 18:51:50 +0000
+++ tests/CMakeLists.txt	2016-04-05 20:43:14 +0000
@@ -85,7 +85,8 @@
             ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}               # arg2: test executable path
             ${TEST_NAME}                                           # arg3: test name
             ${CMAKE_CURRENT_SOURCE_DIR}/test-eds-ics-config-files  # arg4: base directory for config file template
-            ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}.ics)          # arg5: the ical file for this test
+            ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}.ics           # arg5: the ical file for this test
+            ${CMAKE_CURRENT_SOURCE_DIR}/accounts.db)               # arg6: online accounts database
 endfunction()
 add_eds_ics_test_by_name(test-eds-ics-all-day-events)
 add_eds_ics_test_by_name(test-eds-ics-repeating-events)
@@ -95,6 +96,7 @@
 add_eds_ics_test_by_name(test-eds-ics-tzids)
 add_eds_ics_test_by_name(test-eds-ics-tzids-2)
 add_eds_ics_test_by_name(test-eds-ics-tzids-utc)
+add_eds_ics_test_by_name(test-eds-ics-non-attending-alarms)
 
 
 # disabling the timezone unit tests because they require

=== added file 'tests/accounts.db'
Binary files tests/accounts.db	1970-01-01 00:00:00 +0000 and tests/accounts.db	2016-04-05 20:43:14 +0000 differ
=== modified file 'tests/run-eds-ics-test.sh'
--- tests/run-eds-ics-test.sh	2015-07-20 16:31:28 +0000
+++ tests/run-eds-ics-test.sh	2016-04-05 20:43:14 +0000
@@ -6,6 +6,7 @@
 TEST_NAME=$3   # test name
 CONFIG_DIR=$4  # config files
 ICS_FILE=$5    # ical file holding test data
+ACCOUNTS_DB=$6 # online account database
 
 echo "this script: ${SELF}"
 echo "test-runner: ${TEST_RUNNER}"
@@ -54,8 +55,15 @@
   cp --verbose --archive ${ICS_FILE} ${XDG_DATA_HOME}/evolution/tasks/system/tasks.ics
 fi
 
+# prepare online accounts database
+if [ -e ${ACCOUNTS_DB} ]; then
+  echo "copying ${ACCOUNTS_DB} into $HOME"
+  mkdir -p ${XDG_CONFIG_HOME}/libaccounts-glib/
+  cp --verbose --archive ${ACCOUNTS_DB} ${XDG_CONFIG_HOME}/libaccounts-glib/accounts.db
+fi
+
 # run the test
-${TEST_RUNNER} --keep-env --max-wait=90 --task ${TEST_EXEC} --task-name ${TEST_NAME} --wait-until-complete 
+${TEST_RUNNER} --keep-env --max-wait=90 --task ${TEST_EXEC} --task-name ${TEST_NAME} --wait-until-complete
 rv=$?
 
 # if the test passed, blow away the tmpdir

=== modified file 'tests/test-eds-ics-all-day-events.cpp'
--- tests/test-eds-ics-all-day-events.cpp	2015-05-21 12:47:24 +0000
+++ tests/test-eds-ics-all-day-events.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150521T111538Z-7449-1000-3572-0@ghidorah";

=== modified file 'tests/test-eds-ics-missing-trigger.cpp'
--- tests/test-eds-ics-missing-trigger.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-missing-trigger.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MissingTriggers)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -109,6 +110,7 @@
 
     // the planner should match what we've got in the calendar.ics file
     const auto appts = planner->appointments().get();
+    EXPECT_EQ(expected.size(), appts.size());
     EXPECT_EQ(expected, appts);
 
     // cleanup

=== added file 'tests/test-eds-ics-non-attending-alarms.cpp'
--- tests/test-eds-ics-non-attending-alarms.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-eds-ics-non-attending-alarms.cpp	2016-04-05 20:43:14 +0000
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Charles Kerr <[e-mail]>
+ */
+
+#include <algorithm>
+
+#include <datetime/alarm-queue-simple.h>
+#include <datetime/clock-mock.h>
+#include <datetime/engine-eds.h>
+#include <datetime/myself.h>
+#include <datetime/planner-range.h>
+
+#include <gtest/gtest.h>
+
+#include "glib-fixture.h"
+#include "print-to.h"
+#include "timezone-mock.h"
+#include "wakeup-timer-mock.h"
+
+using namespace unity::indicator::datetime;
+using VAlarmFixture = GlibFixture;
+
+/***
+****
+***/
+
+TEST_F(VAlarmFixture, NonAttendingEvent)
+{
+    // start the EDS engine
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
+
+    // we need a consistent timezone for the planner and our local DateTimes
+    constexpr char const * zone_str {"America/Recife"};
+    auto tz = std::make_shared<MockTimezone>(zone_str);
+    auto gtz = g_time_zone_new(zone_str);
+
+    // make a planner that looks at the first half of 2016 in EDS
+    auto planner = std::make_shared<SimpleRangePlanner>(engine, tz);
+    const DateTime range_begin {gtz, 2016,1, 1, 0, 0, 0.0};
+    const DateTime range_end   {gtz, 2016,6,31,23,59,59.5};
+    planner->range().set(std::make_pair(range_begin, range_end));
+
+    // give EDS a moment to load
+    if (planner->appointments().get().empty()) {
+        g_message("waiting a moment for EDS to load...");
+        auto on_appointments_changed = [this](const std::vector<Appointment>& appointments){
+            g_message("ah, they loaded");
+            if (!appointments.empty())
+                g_main_loop_quit(loop);
+        };
+        core::ScopedConnection conn(planner->appointments().changed().connect(on_appointments_changed));
+        constexpr int max_wait_sec = 10;
+        wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
+    }
+
+    // the planner should match what we've got in the calendar.ics file
+    const auto appts = planner->appointments().get();
+    ASSERT_EQ(2, appts.size());
+
+    // cleanup
+    g_time_zone_unref(gtz);
+}

=== added file 'tests/test-eds-ics-non-attending-alarms.ics.in'
--- tests/test-eds-ics-non-attending-alarms.ics.in	1970-01-01 00:00:00 +0000
+++ tests/test-eds-ics-non-attending-alarms.ics.in	2016-04-05 20:43:14 +0000
@@ -0,0 +1,53 @@
+BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+PRODID:-//Ximian//NONSGML Evolution Calendar//EN
+VERSION:2.0
+X-EVOLUTION-DATA-REVISION:2015-04-05T21:32:47.354433Z(2)
+BEGIN:VEVENT
+STATUS:CONFIRMED
+DTSTAMP:20160405T152128Z
+CREATED:20160405T152128Z
+UID:[e-mail]
+SEQUENCE:1
+TRANSP:OPAQUE
+SUMMARY:Every day at 4PM
+DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160404T160000
+RRULE:FREQ=DAILY;UNTIL=20160406T190000Z
+DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160404T170000
+ATTENDEE;CN=Uphablet;PARTSTAT=NEEDS-ACTION;ROLE=REQ-PARTICIPANT;
+ CUTYPE=INDIVIDUAL:mailto:[e-mail]
+LAST-MODIFIED:20160405T152128Z
+BEGIN:VALARM
+TRIGGER;VALUE=DURATION:-PT30M
+ACTION:EMAIL
+DESCRIPTION:This is an event reminder
+X-EVOLUTION-ALARM-UID:20160405T152128Z-2848-32011-1844-65@ubuntu-phablet
+END:VALARM
+END:VEVENT
+BEGIN:VEVENT
+STATUS:CONFIRMED
+DTSTAMP:20160405T152128Z
+CREATED:20160405T151054Z
+UID:[e-mail]
+SEQUENCE:1
+TRANSP:OPAQUE
+SUMMARY::Every day at 4PM
+DTSTART;TZID=/freeassociation.sourceforge.net/Tzfile/America/Fortaleza:
+ 20160405T160000
+RECURRENCE-ID;TZID=/freeassociation.sourceforge.net/Tzfile/America/Recife:
+ 20160405T160000
+DTEND;TZID=/freeassociation.sourceforge.net/Tzfile/America/Fortaleza:
+ 20160405T170000
+ATTENDEE;CN=Uphablet;PARTSTAT=DECLINED;ROLE=REQ-PARTICIPANT;
+ CUTYPE=INDIVIDUAL:mailto:[e-mail]
+LAST-MODIFIED:20160405T152128Z
+BEGIN:VALARM
+TRIGGER;VALUE=DURATION:-PT30M
+ACTION:EMAIL
+DESCRIPTION:This is an event reminder
+X-EVOLUTION-ALARM-UID:20160405T152128Z-2848-32011-1844-66@ubuntu-phablet
+END:VALARM
+END:VEVENT
+END:VCALENDAR

=== modified file 'tests/test-eds-ics-nonrepeating-events.cpp'
--- tests/test-eds-ics-nonrepeating-events.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-nonrepeating-events.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150520T000726Z-3878-32011-1770-81@ubuntu-phablet";

=== modified file 'tests/test-eds-ics-repeating-events.cpp'
--- tests/test-eds-ics-repeating-events.cpp	2015-10-13 14:40:02 +0000
+++ tests/test-eds-ics-repeating-events.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};
@@ -66,7 +67,7 @@
         constexpr int max_wait_sec = 10;
         wait_msec(max_wait_sec * G_TIME_SPAN_MILLISECOND);
     }
-   
+
     // what we expect to get...
     Appointment expected_appt;
     expected_appt.uid = "20150507T211449Z-4262-32011-1418-1@ubuntu-phablet";

=== modified file 'tests/test-eds-ics-repeating-valarms.cpp'
--- tests/test-eds-ics-repeating-valarms.cpp	2015-05-20 23:23:32 +0000
+++ tests/test-eds-ics-repeating-valarms.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Chicago"};

=== modified file 'tests/test-eds-ics-tzids-2.cpp'
--- tests/test-eds-ics-tzids-2.cpp	2015-07-09 20:56:13 +0000
+++ tests/test-eds-ics-tzids-2.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Los_Angeles"};

=== modified file 'tests/test-eds-ics-tzids-utc.cpp'
--- tests/test-eds-ics-tzids-utc.cpp	2016-03-22 19:13:10 +0000
+++ tests/test-eds-ics-tzids-utc.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, UTCAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"America/Recife"};

=== modified file 'tests/test-eds-ics-tzids.cpp'
--- tests/test-eds-ics-tzids.cpp	2015-07-09 19:14:32 +0000
+++ tests/test-eds-ics-tzids.cpp	2016-04-05 20:43:14 +0000
@@ -22,6 +22,7 @@
 #include <datetime/alarm-queue-simple.h>
 #include <datetime/clock-mock.h>
 #include <datetime/engine-eds.h>
+#include <datetime/myself.h>
 #include <datetime/planner-range.h>
 
 #include <gtest/gtest.h>
@@ -41,7 +42,7 @@
 TEST_F(VAlarmFixture, MultipleAppointments)
 {
     // start the EDS engine
-    auto engine = std::make_shared<EdsEngine>();
+    auto engine = std::make_shared<EdsEngine>(std::make_shared<Myself>());
 
     // we need a consistent timezone for the planner and our local DateTimes
     constexpr char const * zone_str {"Europe/Berlin"};