Merge lp:~larsu/indicator-datetime/remove-test-warnings into lp:indicator-datetime/15.10

[Lars Karlitski]

Remove warnings from test logs

Swallow the ones that are expected and fail the test if they don't show up. In addition, fail tests if unexpected warnings show up again.

Also remove some dead code that dealt with counting log emissions.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:421
http://jenkins.qa.ubuntu.com/job/indicator-datetime-ci/328/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-amd64-ci/18/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-datetime-wily-armhf-ci/18/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-datetime-ci/328/rebuild

review: Needs Fixing (continuous-integration)

[lp:~larsu/indicator-datetime/remove-test-warnings]

426. By Lars Karlitski on 2015-09-03

timezone-timedated: subscribe to PropertiesChanged directly

This avoids some unnecessary calls that GDBusProxy makes and the name
watching.

427. By Lars Karlitski on 2015-09-09

test-utils: don't pass NULL as gsettings string value

NULL is not a valid string. Use the empty string instead.

428. By Lars Karlitski on 2015-09-09

glib-fixture: fail tests on unexpected warnings

This requires specifying which warnings are expected to be thrown (only
test-timezone-file needed this for now).

However, only fail on warnings in the Indicator-Datetime log domain so
that we don't fail on gstreamer (or other library) warnings for now.

429. By Lars Karlitski on 2015-09-09

state-fixture: use TestDBusFixture for system bus

Unmerged revisions

=== renamed file 'include/datetime/timezone-file.h' => 'include/datetime/timezone-timedated.h'
--- include/datetime/timezone-file.h	2014-09-13 20:45:23 +0000
+++ include/datetime/timezone-timedated.h	2015-09-03 14:15:27 +0000
@@ -17,8 +17,10 @@
  *   Charles Kerr <[e-mail]>
  */
 
-#ifndef INDICATOR_DATETIME_FILE_TIMEZONE_H
-#define INDICATOR_DATETIME_FILE_TIMEZONE_H
+#ifndef INDICATOR_DATETIME_TIMEDATED_TIMEZONE_H
+#define INDICATOR_DATETIME_TIMEDATED_TIMEZONE_H
+
+#define DEFAULT_FILENAME "/etc/timezone"
 
 #include <datetime/timezone.h> // base class
 
@@ -31,11 +33,11 @@
 /**
  * \brief A #Timezone that gets its information from monitoring a file, such as /etc/timezone
  */
-class FileTimezone: public Timezone
+class TimedatedTimezone: public Timezone
 {
 public:
-    FileTimezone(const std::string& filename);
-    ~FileTimezone();
+    TimedatedTimezone(std::string filename = DEFAULT_FILENAME);
+    ~TimedatedTimezone();
 
 private:
     class Impl;
@@ -43,12 +45,12 @@
     std::unique_ptr<Impl> impl;
 
     // we have pointers in here, so disable copying
-    FileTimezone(const FileTimezone&) =delete;
-    FileTimezone& operator=(const FileTimezone&) =delete;
+    TimedatedTimezone(const TimedatedTimezone&) =delete;
+    TimedatedTimezone& operator=(const TimedatedTimezone&) =delete;
 };
 
 } // namespace datetime
 } // namespace indicator
 } // namespace unity
 
-#endif // INDICATOR_DATETIME_FILE_TIMEZONE_H
+#endif // INDICATOR_DATETIME_TIMEDATED_TIMEZONE_H

=== modified file 'include/datetime/timezones-live.h'
--- include/datetime/timezones-live.h	2014-01-30 19:44:12 +0000
+++ include/datetime/timezones-live.h	2015-09-03 14:15:27 +0000
@@ -22,8 +22,8 @@
 
 #include <datetime/settings.h>
 #include <datetime/timezones.h>
-#include <datetime/timezone-file.h>
 #include <datetime/timezone-geoclue.h>
+#include <datetime/timezone-timedated.h>
 
 #include <memory> // shared_ptr<>
 
@@ -32,19 +32,19 @@
 namespace datetime {
 
 /**
- * \brief #Timezones object that uses a #FileTimezone and #GeoclueTimezone
+ * \brief #Timezones object that uses a #TimedatedTimezone and #GeoclueTimezone
  *        to detect what timezone we're in
  */
 class LiveTimezones: public Timezones
 {
 public:
-    LiveTimezones(const std::shared_ptr<const Settings>& settings, const std::string& filename);
+    LiveTimezones(const std::shared_ptr<const Settings>& settings);
 
 private:
     void update_geolocation();
     void update_timezones();
 
-    FileTimezone m_file;
+    TimedatedTimezone m_file;
     std::shared_ptr<const Settings> m_settings;
     std::shared_ptr<GeoclueTimezone> m_geo;
 };

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-01-21 20:25:52 +0000
+++ src/CMakeLists.txt	2015-09-03 14:15:27 +0000
@@ -1,8 +1,7 @@
 set (SERVICE_LIB "indicatordatetimeservice")
 set (SERVICE_EXEC "indicator-datetime-service")
 
-add_definitions (-DTIMEZONE_FILE="/etc/timezone"
-                 -DG_LOG_DOMAIN="Indicator-Datetime")
+add_definitions (-DG_LOG_DOMAIN="Indicator-Datetime")
 
 # handwritten sources
 set (SERVICE_C_SOURCES
@@ -34,9 +33,9 @@
      settings-live.cpp
      snap.cpp
      sound.cpp
-     timezone-file.cpp
      timezone-geoclue.cpp
      timezones-live.cpp
+     timezone-timedated.cpp
      utils.c
      wakeup-timer-mainloop.cpp
      wakeup-timer-powerd.cpp)

=== modified file 'src/main.cpp'
--- src/main.cpp	2015-04-03 18:11:39 +0000
+++ src/main.cpp	2015-09-03 14:15:27 +0000
@@ -31,8 +31,8 @@
 #include <datetime/settings-live.h>
 #include <datetime/snap.h>
 #include <datetime/state.h>
-#include <datetime/timezone-file.h>
 #include <datetime/timezones-live.h>
+#include <datetime/timezone-timedated.h>
 #include <datetime/wakeup-timer-powerd.h>
 #include <notifications/notifications.h>
 
@@ -68,7 +68,7 @@
     {
         // create the live objects
         auto live_settings = std::make_shared<LiveSettings>();
-        auto live_timezones = std::make_shared<LiveTimezones>(live_settings, TIMEZONE_FILE);
+        auto live_timezones = std::make_shared<LiveTimezones>(live_settings);
         auto live_clock = std::make_shared<LiveClock>(timezone_);
 
         // create a full-month planner currently pointing to the current month
@@ -128,7 +128,7 @@
     textdomain(GETTEXT_PACKAGE);
 
     auto engine = create_engine();
-    auto timezone_ = std::make_shared<FileTimezone>(TIMEZONE_FILE);
+    auto timezone_ = std::make_shared<TimedatedTimezone>();
     auto state = create_state(engine, timezone_);
     auto actions = std::make_shared<LiveActions>(state);
     MenuFactory factory(actions, state);

=== renamed file 'src/timezone-file.cpp' => 'src/timezone-timedated.cpp'
--- src/timezone-file.cpp	2014-09-13 20:45:23 +0000
+++ src/timezone-timedated.cpp	2015-09-03 14:15:27 +0000
@@ -17,7 +17,7 @@
  *   Charles Kerr <[e-mail]>
  */
 
-#include <datetime/timezone-file.h>
+#include <datetime/timezone-timedated.h>
 
 #include <gio/gio.h>
 
@@ -32,14 +32,16 @@
 ****
 ***/
 
-class FileTimezone::Impl
+class TimedatedTimezone::Impl
 {
 public:
 
-    Impl(FileTimezone& owner, const std::string& filename):
-        m_owner(owner)
+    Impl(TimedatedTimezone& owner, std::string filename):
+        m_owner(owner),
+        m_filename(filename)
     {
-        set_filename(filename);
+        g_debug("Filename is '%s'", filename.c_str());
+        monitor_timezone_property();
     }
 
     ~Impl()
@@ -51,65 +53,152 @@
 
     void clear()
     {
-        if (m_monitor_handler_id)
-            g_signal_handler_disconnect(m_monitor, m_monitor_handler_id);
-
-        g_clear_object (&m_monitor);
-
-        m_filename.clear();
-    }
-
-    void set_filename(const std::string& filename)
-    {
-        clear();
-
-        auto tmp = realpath(filename.c_str(), nullptr);
-        if(tmp != nullptr)
-        {
-            m_filename = tmp;
-            free(tmp);
-        }
-        else
-        {
-            g_warning("Unable to resolve path '%s': %s", filename.c_str(), g_strerror(errno));
-            m_filename = filename; // better than nothing?
-        }
-
-        auto file = g_file_new_for_path(m_filename.c_str());
-        GError * err = nullptr;
-        m_monitor = g_file_monitor_file(file, G_FILE_MONITOR_NONE, nullptr, &err);
-        g_object_unref(file);
+        if (m_bus_watch_id)
+        {
+            g_bus_unwatch_name (m_bus_watch_id);
+            m_bus_watch_id = 0;
+        }
+
+        if (m_properties_changed_id)
+        {
+            g_signal_handler_disconnect(m_proxy, m_properties_changed_id);
+            m_properties_changed_id = 0;
+        }
+
+        g_clear_object(&m_proxy);
+    }
+
+    static void on_properties_changed(GDBusProxy *proxy G_GNUC_UNUSED,
+            GVariant *changed_properties /* a{sv} */,
+            GStrv invalidated_properties G_GNUC_UNUSED,
+            gpointer gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+        char *tz;
+
+        if (g_variant_lookup(changed_properties, "Timezone", "s", &tz, NULL))
+        {
+            g_debug("on_properties_changed: got timezone '%s'", tz);
+            self->notify_timezone(tz);
+            g_free (tz);
+        }
+    }
+
+    static void on_proxy_ready(GObject *object G_GNUC_UNUSED,
+            GAsyncResult *res,
+            gpointer gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+        GError *error = nullptr;
+        self->m_proxy = g_dbus_proxy_new_finish(res, &error);
+
+        if (error)
+        {
+            g_warning ("Couldn't create proxy to read timezone: %s", error->message);
+            goto out;
+        }
+
+        /* Read the property */
+        GVariant *prop;
+        prop = g_dbus_proxy_get_cached_property(self->m_proxy, "Timezone");
+
+        if (!prop || !g_variant_is_of_type(prop, G_VARIANT_TYPE_STRING))
+        {
+            g_warning("Couldn't read the Timezone property, defaulting to Etc/Utc");
+            self->notify_timezone("Etc/Utc");
+            goto out;
+        }
+
+        const gchar *tz;
+        tz = g_variant_get_string(prop, nullptr);
+
+        self->notify_timezone(tz);
+
+        self->m_properties_changed_id = g_signal_connect(self->m_proxy,
+                "g-properties-changed",
+                (GCallback) on_properties_changed,
+                gself);
+
+out:
+        g_clear_pointer(&error, g_error_free);
+        g_clear_pointer(&prop, g_variant_unref);
+    }
+
+    static void on_name_appeared(GDBusConnection *connection,
+            const gchar *name,
+            const gchar *name_owner G_GNUC_UNUSED,
+            gpointer gself G_GNUC_UNUSED)
+    {
+        g_debug ("timedate1 appeared");
+        g_dbus_proxy_new(connection,
+                G_DBUS_PROXY_FLAGS_NONE,
+                NULL,
+                name,
+                "/org/freedesktop/timedate1",
+                "org.freedesktop.timedate1",
+                nullptr,
+                on_proxy_ready,
+                gself);
+    }
+
+    static void on_name_vanished(GDBusConnection *connection G_GNUC_UNUSED,
+            const gchar *name G_GNUC_UNUSED,
+            gpointer gself)
+    {
+        auto self = static_cast<Impl*>(gself);
+        g_debug ("timedate1 vanished");
+
+        g_signal_handler_disconnect(self->m_proxy,
+                self->m_properties_changed_id);
+        self->m_properties_changed_id = 0;
+        g_clear_object(&self->m_proxy);
+        g_clear_pointer(&self->m_proxy, g_main_loop_unref);
+    }
+
+    void monitor_timezone_property()
+    {
+        GError *err = nullptr;
+        GDBusConnection *conn;
+
+        /*
+         * There is an unlikely race which happens if there is an activation
+         * and timezone change before our match rule is added.
+         */
+        notify_timezone(get_timezone_from_file(m_filename));
+
+        /*
+         * Make sure the bus is around at least until we add the match rules,
+         * otherwise things (tests) are sad.
+         */
+        conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM,
+                nullptr,
+                &err);
+
         if (err)
         {
-            g_warning("%s Unable to monitor timezone file '%s': %s", G_STRLOC, TIMEZONE_FILE, err->message);
+            g_warning("Couldn't get bus connection: '%s'", err->message);
             g_error_free(err);
-        }
-        else
-        {
-            m_monitor_handler_id = g_signal_connect_swapped(m_monitor, "changed", G_CALLBACK(on_file_changed), this);
-            g_debug("%s Monitoring timezone file '%s'", G_STRLOC, m_filename.c_str());
-        }
-
-        reload();
-    }
-
-    static void on_file_changed(gpointer gself)
-    {
-        static_cast<Impl*>(gself)->reload();
-    }
-
-    void reload()
-    {
-        const auto new_timezone = get_timezone_from_file(m_filename);
-
+            return;
+        }
+
+        m_bus_watch_id = g_bus_watch_name_on_connection(conn,
+                "org.freedesktop.timedate1",
+                G_BUS_NAME_WATCHER_FLAGS_NONE,
+                on_name_appeared,
+                on_name_vanished,
+                this,
+                nullptr);
+
+        g_object_unref (conn);
+    }
+
+    void notify_timezone(std::string new_timezone)
+    {
+        g_debug("notify_timezone '%s'", new_timezone.c_str());
         if (!new_timezone.empty())
             m_owner.timezone.set(new_timezone);
     }
 
-    /***
-    ****
-    ***/
-
     std::string get_timezone_from_file(const std::string& filename)
     {
         GError * error;
@@ -143,7 +232,9 @@
             }
 
             g_string_free(line, true);
-        }
+        } else
+            /* Default to UTC */
+            ret = "Etc/Utc";
 
         if (io_channel != nullptr)
         {
@@ -164,22 +255,23 @@
     ****
     ***/
 
-    FileTimezone & m_owner;
+    TimedatedTimezone & m_owner;
+    unsigned long m_properties_changed_id = 0;
+    unsigned long m_bus_watch_id = 0;
+    GDBusProxy *m_proxy = nullptr;
     std::string m_filename;
-    GFileMonitor * m_monitor = nullptr;
-    unsigned long m_monitor_handler_id = 0;
 };
 
 /***
 ****
 ***/
 
-FileTimezone::FileTimezone(const std::string& filename):
+TimedatedTimezone::TimedatedTimezone(std::string filename):
     impl(new Impl{*this, filename})
 {
 }
 
-FileTimezone::~FileTimezone()
+TimedatedTimezone::~TimedatedTimezone()
 {
 }
 

=== modified file 'src/timezones-live.cpp'
--- src/timezones-live.cpp	2014-01-30 19:44:12 +0000
+++ src/timezones-live.cpp	2015-09-03 14:15:27 +0000
@@ -25,9 +25,8 @@
 namespace indicator {
 namespace datetime {
 
-LiveTimezones::LiveTimezones(const std::shared_ptr<const Settings>& settings,
-                             const std::string& filename):
-    m_file(filename),
+LiveTimezones::LiveTimezones(const std::shared_ptr<const Settings>& settings):
+    m_file(),
     m_settings(settings)
 {
     m_file.timezone.changed().connect([this](const std::string&){update_timezones();});

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-07-22 12:00:11 +0000
+++ tests/CMakeLists.txt	2015-09-03 14:15:27 +0000
@@ -38,6 +38,7 @@
 
 
 add_definitions (-DSANDBOX="${CMAKE_CURRENT_BINARY_DIR}")
+add_definitions (-DG_LOG_DOMAIN="Indicator-Datetime")
 
 function(add_test_by_name name)
   set (TEST_NAME ${name})
@@ -58,7 +59,7 @@
 add_test_by_name(test-menus)
 add_test_by_name(test-planner)
 add_test_by_name(test-settings)
-add_test_by_name(test-timezone-file)
+add_test_by_name(test-timezone-timedated)
 add_test_by_name(test-utils)
 
 set (TEST_NAME manual-test-snap)

=== modified file 'tests/glib-fixture.h'
--- tests/glib-fixture.h	2014-09-17 16:51:51 +0000
+++ tests/glib-fixture.h	2015-09-03 14:15:27 +0000
@@ -36,34 +36,6 @@
 
     virtual ~GlibFixture() =default;
 
-  private:
-
-    //GLogFunc realLogHandler;
-
-  protected:
-
-    std::map<GLogLevelFlags,int> logCounts;
-
-    void testLogCount(GLogLevelFlags log_level, int /*expected*/)
-    {
-#if 0
-      EXPECT_EQ(expected, logCounts[log_level]);
-#endif
-
-      logCounts.erase(log_level);
-    }
-
-  private:
-
-    static void default_log_handler(const gchar    * log_domain,
-                                    GLogLevelFlags   log_level,
-                                    const gchar    * message,
-                                    gpointer         self)
-    {
-      g_print("%s - %d - %s\n", log_domain, (int)log_level, message);
-      static_cast<GlibFixture*>(self)->logCounts[log_level]++;
-    }
-
   protected:
 
     virtual void SetUp() override
@@ -72,34 +44,30 @@
 
       loop = g_main_loop_new(nullptr, false);
 
-      //g_log_set_default_handler(default_log_handler, this);
-
       // only use local, temporary settings
       g_assert(g_setenv("GSETTINGS_SCHEMA_DIR", SCHEMA_DIR, true));
       g_assert(g_setenv("GSETTINGS_BACKEND", "memory", true));
       g_debug("SCHEMA_DIR is %s", SCHEMA_DIR);
 
+      // fail on unexpected messages from this domain
+      g_log_set_fatal_mask(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING);
+
       g_unsetenv("DISPLAY");
 
     }
 
     virtual void TearDown() override
     {
-#if 0
-      // confirm there aren't any unexpected log messages
-      EXPECT_EQ(0, logCounts[G_LOG_LEVEL_ERROR]);
-      EXPECT_EQ(0, logCounts[G_LOG_LEVEL_CRITICAL]);
-      EXPECT_EQ(0, logCounts[G_LOG_LEVEL_WARNING]);
-      EXPECT_EQ(0, logCounts[G_LOG_LEVEL_MESSAGE]);
-      EXPECT_EQ(0, logCounts[G_LOG_LEVEL_INFO]);
-#endif
-
-      // revert to glib's log handler
-      //g_log_set_default_handler(realLogHandler, this);
+      g_test_assert_expected_messages ();
 
       g_clear_pointer(&loop, g_main_loop_unref);
     }
 
+    void expectLogMessage (const gchar *domain, GLogLevelFlags level, const gchar *pattern)
+    {
+      g_test_expect_message (domain, level, pattern);
+    }
+
   private:
 
     static gboolean

=== modified file 'tests/test-live-actions.cpp'
--- tests/test-live-actions.cpp	2015-03-31 23:54:04 +0000
+++ tests/test-live-actions.cpp	2015-09-03 14:15:27 +0000
@@ -17,228 +17,18 @@
  *   Charles Kerr <[e-mail]>
  */
 
-#include <datetime/actions-live.h>
-
-#include "state-mock.h"
-#include "glib-fixture.h"
-
-/***
-****
-***/
-
-using namespace unity::indicator::datetime;
-
-class MockLiveActions: public LiveActions
-{
-public:
-    std::string last_cmd;
-    std::string last_url;
-    explicit MockLiveActions(const std::shared_ptr<State>& state_in): LiveActions(state_in) {}
-    ~MockLiveActions() {}
-
-protected:
-    void dispatch_url(const std::string& url) override { last_url = url; }
-    void execute_command(const std::string& cmd) override { last_cmd = cmd; }
-};
-
-/***
-****
-***/
-
-using namespace unity::indicator::datetime;
-
-class LiveActionsFixture: public GlibFixture
-{
-private:
-
-    typedef GlibFixture super;
-
-    static void on_bus_acquired(GDBusConnection* conn,
-                                const gchar* name,
-                                gpointer gself)
-    {
-        auto self = static_cast<LiveActionsFixture*>(gself);
-        g_debug("bus acquired: %s, connection is %p", name, conn);
-
-        // Set up a mock GSD.
-        // All it really does is wait for calls to GetDevice and
-        // returns the get_devices_retval variant
-        static const GDBusInterfaceVTable vtable = {
-            timedate1_handle_method_call,
-            nullptr, /* GetProperty */
-            nullptr, /* SetProperty */
-        };
-
-        self->connection = G_DBUS_CONNECTION(g_object_ref(G_OBJECT(conn)));
-
-        GError* error = nullptr;
-        self->object_register_id = g_dbus_connection_register_object(
-            conn,
-            "/org/freedesktop/timedate1",
-            self->node_info->interfaces[0],
-            &vtable,
-            self,
-            nullptr,
-            &error);
-        g_assert_no_error(error);
-    }
-
-    static void on_name_acquired(GDBusConnection* /*conn*/,
-                                 const gchar*     /*name*/,
-                                 gpointer           gself)
-    {
-        auto self = static_cast<LiveActionsFixture*>(gself);
-        self->name_acquired = true;
-        g_main_loop_quit(self->loop);
-    }
-
-    static void on_name_lost(GDBusConnection* /*conn*/,
-                             const gchar*     /*name*/,
-                             gpointer           gself)
-    {
-        auto self = static_cast<LiveActionsFixture*>(gself);
-        self->name_acquired = false;
-    }
-
-    static void on_bus_closed(GObject*       /*object*/,
-                              GAsyncResult*    res,
-                              gpointer         gself)
-    {
-        auto self = static_cast<LiveActionsFixture*>(gself);
-        GError* err = nullptr;
-        g_dbus_connection_close_finish(self->connection, res, &err);
-        g_assert_no_error(err);
-        g_main_loop_quit(self->loop);
-    }
-
-    static void
-    timedate1_handle_method_call(GDBusConnection       * /*connection*/,
-                                 const gchar           * /*sender*/,
-                                 const gchar           * /*object_path*/,
-                                 const gchar           * /*interface_name*/,
-                                 const gchar           *   method_name,
-                                 GVariant              *   parameters,
-                                 GDBusMethodInvocation *   invocation,
-                                 gpointer                  gself)
-    {
-        g_assert(!g_strcmp0(method_name, "SetTimezone"));
-        g_assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE_TUPLE));
-        g_assert(2 == g_variant_n_children(parameters));
-
-        auto child = g_variant_get_child_value(parameters, 0);
-        g_assert(g_variant_is_of_type(child, G_VARIANT_TYPE_STRING));
-        auto self = static_cast<LiveActionsFixture*>(gself);
-        self->attempted_tzid = g_variant_get_string(child, nullptr);
-        g_variant_unref(child);
-
-        g_dbus_method_invocation_return_value(invocation, nullptr);
-        g_main_loop_quit(self->loop);
-    }
-
-protected:
-
-    std::shared_ptr<MockState> m_mock_state;
-    std::shared_ptr<State> m_state;
-    std::shared_ptr<MockLiveActions> m_live_actions;
-    std::shared_ptr<Actions> m_actions;
-
-    bool name_acquired;
-    std::string attempted_tzid;
-
-    GTestDBus* bus;
-    guint own_name;
-    GDBusConnection* connection;
-    GDBusNodeInfo* node_info;
-    int object_register_id;
-
-    void SetUp()
-    {
-        super::SetUp();
-
-        name_acquired = false;
-        attempted_tzid.clear();
-        connection = nullptr;
-        node_info = nullptr;
-        object_register_id = 0;
-        own_name = 0;
-
-        // bring up the test bus
-        bus = g_test_dbus_new(G_TEST_DBUS_NONE);
-        g_test_dbus_up(bus);
-        const auto address = g_test_dbus_get_bus_address(bus);
-        g_setenv("DBUS_SYSTEM_BUS_ADDRESS", address, true);
-        g_setenv("DBUS_SESSION_BUS_ADDRESS", address, true);
-        g_debug("test_dbus's address is %s", address);
-
-        // parse the org.freedesktop.timedate1 interface
-        const gchar introspection_xml[] =
-            "<node>"
-            "  <interface name='org.freedesktop.timedate1'>"
-            "    <method name='SetTimezone'>"
-            "      <arg name='timezone' type='s' direction='in'/>"
-            "      <arg name='user_interaction' type='b' direction='in'/>"
-            "    </method>"
-            "  </interface>"
-            "</node>";
-        node_info = g_dbus_node_info_new_for_xml(introspection_xml, nullptr);
-        ASSERT_TRUE(node_info != nullptr);
-        ASSERT_TRUE(node_info->interfaces != nullptr);
-        ASSERT_TRUE(node_info->interfaces[0] != nullptr);
-        ASSERT_TRUE(node_info->interfaces[1] == nullptr);
-        ASSERT_STREQ("org.freedesktop.timedate1", node_info->interfaces[0]->name);
-
-        // own the bus
-        own_name = g_bus_own_name(G_BUS_TYPE_SYSTEM,
-                                  "org.freedesktop.timedate1",
-                                  G_BUS_NAME_OWNER_FLAGS_NONE,
-                                  on_bus_acquired, on_name_acquired, on_name_lost,
-                                  this, nullptr);
-        ASSERT_TRUE(object_register_id == 0);
-        ASSERT_FALSE(name_acquired);
-        ASSERT_TRUE(connection == nullptr);
-        g_main_loop_run(loop);
-        ASSERT_TRUE(object_register_id != 0);
-        ASSERT_TRUE(name_acquired);
-        ASSERT_TRUE(G_IS_DBUS_CONNECTION(connection));
-
-        // create the State and Actions
-        m_mock_state.reset(new MockState);
-        m_mock_state->settings.reset(new Settings);
-        m_state = std::dynamic_pointer_cast<State>(m_mock_state);
-        m_live_actions.reset(new MockLiveActions(m_state));
-        m_actions = std::dynamic_pointer_cast<Actions>(m_live_actions);
-    }
-
-    void TearDown()
-    {
-        m_actions.reset();
-        m_live_actions.reset();
-        m_state.reset();
-        m_mock_state.reset();
-
-        g_dbus_connection_unregister_object(connection, object_register_id);
-        g_dbus_node_info_unref(node_info);
-        g_bus_unown_name(own_name);
-        g_dbus_connection_close(connection, nullptr, on_bus_closed, this);
-        g_main_loop_run(loop);
-        g_clear_object(&connection);
-        g_test_dbus_down(bus);
-        g_clear_object(&bus);
-
-        super::TearDown();
-    }
-};
-
-/***
-****
-***/
-
-TEST_F(LiveActionsFixture, HelloWorld)
+#include "timedated-fixture.h"
+
+/***
+****
+***/
+
+TEST_F(TimedateFixture, HelloWorld)
 {
     EXPECT_TRUE(true);
 }
 
-TEST_F(LiveActionsFixture, SetLocation)
+TEST_F(TimedateFixture, SetLocation)
 {
     const std::string tzid = "America/Chicago";
     const std::string name = "Oklahoma City";
@@ -247,6 +37,10 @@
     EXPECT_NE(expected, m_state->settings->timezone_name.get());
 
     m_actions->set_location(tzid, name);
+    m_state->settings->timezone_name.changed().connect(
+          [this](const std::string&){
+            g_main_loop_quit(loop);
+            });
     g_main_loop_run(loop);
     EXPECT_EQ(attempted_tzid, tzid);
     wait_msec();
@@ -258,14 +52,14 @@
 ****
 ***/
 
-TEST_F(LiveActionsFixture, DesktopOpenAlarmApp)
+TEST_F(TimedateFixture, 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)
+TEST_F(TimedateFixture, DesktopOpenAppointment)
 {
     Appointment a;
     a.uid = "some-uid";
@@ -275,14 +69,14 @@
     EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
 }
 
-TEST_F(LiveActionsFixture, DesktopOpenCalendarApp)
+TEST_F(TimedateFixture, 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)
+TEST_F(TimedateFixture, DesktopOpenSettingsApp)
 {
     m_actions->desktop_open_settings_app();
     const std::string expected_substr = "control-center";
@@ -300,13 +94,13 @@
     const std::string calendar_app_url = "appid://com.ubuntu.calendar/calendar/current-user-version";
 }
 
-TEST_F(LiveActionsFixture, PhoneOpenAlarmApp)
+TEST_F(TimedateFixture, PhoneOpenAlarmApp)
 {
     m_actions->phone_open_alarm_app();
     EXPECT_EQ(clock_app_url, m_live_actions->last_url);
 }
 
-TEST_F(LiveActionsFixture, PhoneOpenAppointment)
+TEST_F(TimedateFixture, PhoneOpenAppointment)
 {
     Appointment a;
 
@@ -321,14 +115,14 @@
     EXPECT_EQ(clock_app_url, m_live_actions->last_url);
 }
 
-TEST_F(LiveActionsFixture, PhoneOpenCalendarApp)
+TEST_F(TimedateFixture, 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, PhoneOpenSettingsApp)
+TEST_F(TimedateFixture, PhoneOpenSettingsApp)
 {
     m_actions->phone_open_settings_app();
     const std::string expected = "settings:///system/time-date";
@@ -339,7 +133,7 @@
 ****
 ***/
 
-TEST_F(LiveActionsFixture, CalendarState)
+TEST_F(TimedateFixture, CalendarState)
 {
     // init the clock
     auto now = DateTime::Local(2014, 1, 1, 0, 0, 0);

=== renamed file 'tests/test-timezone-file.cpp' => 'tests/test-timezone-timedated.cpp'
--- tests/test-timezone-file.cpp	2014-09-17 16:51:51 +0000
+++ tests/test-timezone-timedated.cpp	2015-09-03 14:15:27 +0000
@@ -18,25 +18,11 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "glib-fixture.h"
-
-#include <datetime/timezone-file.h>
-
-//#include <condition_variable>
-//#include <mutex>
-//#include <queue>
-//#include <string>
-//#include <thread>
-//#include <iostream>
-//#include <istream>
-//#include <fstream>
-
-#include <cstdio> // fopen()
-//#include <sys/stat.h> // chmod()
-#include <unistd.h> // sync()
-
-using unity::indicator::datetime::FileTimezone;
-
+#include "timedated-fixture.h"
+
+#include <datetime/timezone-timedated.h>
+
+using unity::indicator::datetime::TimedatedTimezone;
 
 /***
 ****
@@ -44,11 +30,11 @@
 
 #define TIMEZONE_FILE (SANDBOX"/timezone")
 
-class TimezoneFixture: public GlibFixture
+class TimezoneFixture: public TimedateFixture
 {
   private:
 
-    typedef GlibFixture super;
+    typedef TimedateFixture super;
 
   protected:
 
@@ -67,6 +53,7 @@
     /* convenience func to set the timezone file */
     void set_file(const std::string& text)
     {
+      g_debug("set_file %s %s", TIMEZONE_FILE, text.c_str());
       auto fp = fopen(TIMEZONE_FILE, "w+");
       fprintf(fp, "%s\n", text.c_str());
       fclose(fp);
@@ -74,46 +61,57 @@
     }
 };
 
-
 /**
- * Test that timezone-file warns, but doesn't crash, if the timezone file doesn't exist
+ * Test that timezone-timedated warns, but doesn't crash, if the timezone file doesn't exist
  */
 TEST_F(TimezoneFixture, NoFile)
 {
   remove(TIMEZONE_FILE);
   ASSERT_FALSE(g_file_test(TIMEZONE_FILE, G_FILE_TEST_EXISTS));
 
-  FileTimezone tz(TIMEZONE_FILE);
-  testLogCount(G_LOG_LEVEL_WARNING, 1);
-}
-
-
-/**
- * Test that timezone-file picks up the initial value
+  expectLogMessage(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "*No such file or directory*");
+  TimedatedTimezone tz(TIMEZONE_FILE);
+}
+
+/**
+ * Test that timezone-timedated gives a default of UTC if the file doesn't exist
+ */
+TEST_F(TimezoneFixture, DefaultValueNoFile)
+{
+  const std::string expected_timezone = "Etc/Utc";
+  remove(TIMEZONE_FILE);
+  ASSERT_FALSE(g_file_test(TIMEZONE_FILE, G_FILE_TEST_EXISTS));
+
+  expectLogMessage(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "*No such file or directory*");
+  TimedatedTimezone tz(TIMEZONE_FILE);
+  ASSERT_EQ(expected_timezone, tz.timezone.get());
+}
+
+/**
+ * Test that timezone-timedated picks up the initial value
  */
 TEST_F(TimezoneFixture, InitialValue)
 {
   const std::string expected_timezone = "America/Chicago";
   set_file(expected_timezone);
-  FileTimezone tz(TIMEZONE_FILE);
-  ASSERT_EQ(expected_timezone, tz.timezone.get());
+  TimedatedTimezone tz(TIMEZONE_FILE);
 }
 
-
 /**
- * Test that clearing the timezone results in an empty string
+ * Test that changing the tz after we are running works.
  */
 TEST_F(TimezoneFixture, ChangedValue)
 {
   const std::string initial_timezone = "America/Chicago";
   const std::string changed_timezone = "America/New_York";
+
   set_file(initial_timezone);
 
-  FileTimezone tz(TIMEZONE_FILE);
+  TimedatedTimezone tz(TIMEZONE_FILE);
   ASSERT_EQ(initial_timezone, tz.timezone.get());
 
   bool changed = false;
-  auto connection = tz.timezone.changed().connect(
+  tz.timezone.changed().connect(
         [&changed, this](const std::string& s){
           g_message("timezone changed to %s", s.c_str());
           changed = true;
@@ -121,10 +119,9 @@
         });
 
   g_idle_add([](gpointer gself){
-    static_cast<TimezoneFixture*>(gself)->set_file("America/New_York");
-  //  static_cast<FileTimezone*>(gtz)->timezone.set("America/New_York");
+    static_cast<TimedateFixture*>(gself)->set_timezone("America/New_York");
     return G_SOURCE_REMOVE;
-  }, this);//&tz);
+  }, this);
 
   g_main_loop_run(loop);
 
@@ -132,15 +129,14 @@
   ASSERT_EQ(changed_timezone, tz.timezone.get());
 }
 
-
 /**
- * Test that timezone-file picks up the initial value
+ * Test that timezone-timedated picks up the initial value
  */
 TEST_F(TimezoneFixture, IgnoreComments)
 {
   const std::string comment = "# Created by cloud-init v. 0.7.5 on Thu, 24 Apr 2014 14:03:29 +0000";
   const std::string expected_timezone = "Europe/Berlin";
   set_file(comment + "\n" + expected_timezone);
-  FileTimezone tz(TIMEZONE_FILE);
+  TimedatedTimezone tz(TIMEZONE_FILE);
   ASSERT_EQ(expected_timezone, tz.timezone.get());
 }

=== modified file 'tests/test-utils.cpp'
--- tests/test-utils.cpp	2014-02-02 21:29:29 +0000
+++ tests/test-utils.cpp	2015-09-03 14:15:27 +0000
@@ -59,7 +59,7 @@
         const char* location;
         const char* expected_name;
     } beautify_timezone_test_cases[] = {
-        { "America/Chicago", nullptr, "Chicago" },
+        { "America/Chicago", "", "Chicago" },
         { "America/Chicago", "America/Chicago", "Chicago" },
         { "America/Chicago", "America/Chigago Chicago", "Chicago" },
         { "America/Chicago", "America/Chicago Oklahoma City", "Oklahoma City" },

=== added file 'tests/timedated-fixture.h'
--- tests/timedated-fixture.h	1970-01-01 00:00:00 +0000
+++ tests/timedated-fixture.h	2015-09-03 14:15:27 +0000
@@ -0,0 +1,301 @@
+/*
+ * Copyright 2013 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]>
+ */
+
+#ifndef INDICATOR_DATETIME_TESTS_TIMEDATED_FIXTURE_H
+#define INDICATOR_DATETIME_TESTS_TIMEDATED_FIXTURE_H
+
+#include <datetime/actions-live.h>
+
+#include "state-mock.h"
+#include "glib-fixture.h"
+
+using namespace unity::indicator::datetime;
+
+class MockLiveActions: public LiveActions
+{
+public:
+    std::string last_cmd;
+    std::string last_url;
+    explicit MockLiveActions(const std::shared_ptr<State>& state_in): LiveActions(state_in) {}
+    ~MockLiveActions() {}
+
+protected:
+    void dispatch_url(const std::string& url) override { last_url = url; }
+    void execute_command(const std::string& cmd) override { last_cmd = cmd; }
+};
+
+/***
+****
+***/
+
+using namespace unity::indicator::datetime;
+
+class TimedateFixture: public GlibFixture
+{
+private:
+
+    typedef GlibFixture super;
+
+    static GVariant * timedate1_get_properties (GDBusConnection * /*connection*/ ,
+                                                const gchar * /*sender*/,
+                                                const gchar * /*object_path*/,
+                                                const gchar * /*interface_name*/,
+                                                const gchar *property_name,
+                                                GError ** /*error*/,
+                                                gpointer gself)
+
+    {
+        auto self = static_cast<TimedateFixture*>(gself);
+        g_debug("get_properties called");
+        if (g_strcmp0(property_name, "Timezone") == 0)
+        {
+            g_debug("timezone requested, giving '%s'",
+                    self->attempted_tzid.c_str());
+            return g_variant_new_string(self->attempted_tzid.c_str());
+        }
+        return nullptr;
+    }
+
+
+    static void on_bus_acquired(GDBusConnection* conn,
+                                const gchar* name,
+                                gpointer gself)
+    {
+        auto self = static_cast<TimedateFixture*>(gself);
+        g_debug("bus acquired: %s, connection is %p", name, conn);
+
+        /* Set up a fake timedated which handles setting and getting the
+         ** timezone
+         */
+        static const GDBusInterfaceVTable vtable = {
+            timedate1_handle_method_call,
+            timedate1_get_properties, /* GetProperty */
+            nullptr, /* SetProperty */
+        };
+
+        self->connection = G_DBUS_CONNECTION(g_object_ref(G_OBJECT(conn)));
+
+        GError* error = nullptr;
+        self->object_register_id = g_dbus_connection_register_object(
+            conn,
+            "/org/freedesktop/timedate1",
+            self->node_info->interfaces[0],
+            &vtable,
+            self,
+            nullptr,
+            &error);
+        g_assert_no_error(error);
+    }
+
+    static void on_name_acquired(GDBusConnection* conn,
+                                 const gchar*     name,
+                                 gpointer         gself)
+    {
+        g_debug("on_name_acquired");
+        auto self = static_cast<TimedateFixture*>(gself);
+        self->name_acquired = true;
+        self->proxy = g_dbus_proxy_new_sync(conn,
+                G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+                nullptr,
+                name,
+                "/org/freedesktop/timedate1",
+                "org.freedesktop.timedate1",
+                nullptr,
+                nullptr);
+        g_main_loop_quit(self->loop);
+    }
+
+    static void on_name_lost(GDBusConnection* /*conn*/,
+                             const gchar*     /*name*/,
+                             gpointer           gself)
+    {
+        g_debug("on_name_lost");
+        auto self = static_cast<TimedateFixture*>(gself);
+        self->name_acquired = false;
+    }
+
+    static void on_bus_closed(GObject*       /*object*/,
+                              GAsyncResult*    res,
+                              gpointer         gself)
+    {
+        g_debug("on_bus_closed");
+        auto self = static_cast<TimedateFixture*>(gself);
+        GError* err = nullptr;
+        g_dbus_connection_close_finish(self->connection, res, &err);
+        g_assert_no_error(err);
+        g_main_loop_quit(self->loop);
+    }
+
+    static void
+    timedate1_handle_method_call(GDBusConnection       *   connection,
+                                 const gchar           * /*sender*/,
+                                 const gchar           *   object_path,
+                                 const gchar           *   interface_name,
+                                 const gchar           *   method_name,
+                                 GVariant              *   parameters,
+                                 GDBusMethodInvocation *   invocation,
+                                 gpointer                  gself)
+    {
+        g_assert(!g_strcmp0(method_name, "SetTimezone"));
+        g_assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE_TUPLE));
+        g_assert(2 == g_variant_n_children(parameters));
+
+        auto child = g_variant_get_child_value(parameters, 0);
+        g_assert(g_variant_is_of_type(child, G_VARIANT_TYPE_STRING));
+        auto self = static_cast<TimedateFixture*>(gself);
+        self->attempted_tzid = g_variant_get_string(child, nullptr);
+        g_debug("set tz (dbus side): '%s'", self->attempted_tzid.c_str());
+        g_dbus_method_invocation_return_value(invocation, nullptr);
+
+        /* Send PropertiesChanged */
+        GError * local_error = nullptr;
+        auto builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
+        g_variant_builder_add (builder,
+                               "{sv}",
+                               "Timezone",
+                               g_variant_new_string(
+                                   self->attempted_tzid.c_str()));
+        g_dbus_connection_emit_signal (connection,
+                                       NULL,
+                                       object_path,
+                                       "org.freedesktop.DBus.Properties",
+                                       "PropertiesChanged",
+                                       g_variant_new ("(sa{sv}as)",
+                                                      interface_name,
+                                                      builder,
+                                                      NULL),
+                                       &local_error);
+        g_assert_no_error (local_error);
+        g_variant_unref(child);
+    }
+
+protected:
+
+    std::shared_ptr<MockState> m_mock_state;
+    std::shared_ptr<State> m_state;
+    std::shared_ptr<MockLiveActions> m_live_actions;
+    std::shared_ptr<Actions> m_actions;
+
+    bool name_acquired;
+    std::string attempted_tzid;
+
+    GTestDBus* bus;
+    guint own_name;
+    GDBusConnection* connection;
+    GDBusNodeInfo* node_info;
+    int object_register_id;
+    GDBusProxy *proxy;
+
+    void SetUp()
+    {
+        super::SetUp();
+        g_debug("SetUp");
+
+        name_acquired = false;
+        attempted_tzid.clear();
+        connection = nullptr;
+        node_info = nullptr;
+        object_register_id = 0;
+        own_name = 0;
+        proxy = nullptr;
+
+        // bring up the test bus
+        bus = g_test_dbus_new(G_TEST_DBUS_NONE);
+        g_test_dbus_up(bus);
+        const auto address = g_test_dbus_get_bus_address(bus);
+        g_setenv("DBUS_SYSTEM_BUS_ADDRESS", address, true);
+        g_setenv("DBUS_SESSION_BUS_ADDRESS", address, true);
+        g_debug("test_dbus's address is %s", address);
+
+        // parse the org.freedesktop.timedate1 interface
+        const gchar introspection_xml[] =
+            "<node>"
+            "  <interface name='org.freedesktop.timedate1'>"
+            "  <property name='Timezone' type='s' access='read' />"
+            "    <method name='SetTimezone'>"
+            "      <arg name='timezone' type='s' direction='in'/>"
+            "      <arg name='user_interaction' type='b' direction='in'/>"
+            "    </method>"
+            "  </interface>"
+            "</node>";
+        node_info = g_dbus_node_info_new_for_xml(introspection_xml, nullptr);
+        ASSERT_TRUE(node_info != nullptr);
+        ASSERT_TRUE(node_info->interfaces != nullptr);
+        ASSERT_TRUE(node_info->interfaces[0] != nullptr);
+        ASSERT_TRUE(node_info->interfaces[1] == nullptr);
+        ASSERT_STREQ("org.freedesktop.timedate1", node_info->interfaces[0]->name);
+
+        // own the bus
+        own_name = g_bus_own_name(G_BUS_TYPE_SYSTEM,
+                                  "org.freedesktop.timedate1",
+                                  G_BUS_NAME_OWNER_FLAGS_NONE,
+                                  on_bus_acquired, on_name_acquired, on_name_lost,
+                                  this, nullptr);
+        ASSERT_TRUE(object_register_id == 0);
+        ASSERT_FALSE(name_acquired);
+        ASSERT_TRUE(connection == nullptr);
+        g_main_loop_run(loop);
+        ASSERT_TRUE(object_register_id != 0);
+        ASSERT_TRUE(name_acquired);
+        ASSERT_TRUE(G_IS_DBUS_CONNECTION(connection));
+
+        // create the State and Actions
+        m_mock_state.reset(new MockState);
+        m_mock_state->settings.reset(new Settings);
+        m_state = std::dynamic_pointer_cast<State>(m_mock_state);
+        m_live_actions.reset(new MockLiveActions(m_state));
+        m_actions = std::dynamic_pointer_cast<Actions>(m_live_actions);
+    }
+
+    void TearDown()
+    {
+        g_debug("TearDown");
+        m_actions.reset();
+        m_live_actions.reset();
+        m_state.reset();
+        m_mock_state.reset();
+        g_dbus_connection_unregister_object(connection, object_register_id);
+        g_object_unref(proxy);
+        g_dbus_node_info_unref(node_info);
+        g_bus_unown_name(own_name);
+        g_dbus_connection_close(connection, nullptr, on_bus_closed, this);
+        g_main_loop_run(loop);
+        g_clear_object(&connection);
+        g_test_dbus_down(bus);
+        g_clear_object(&bus);
+
+        super::TearDown();
+    }
+public:
+    void set_timezone(std::string tz)
+    {
+        g_debug("set_timezone: '%s'", tz.c_str());
+        g_dbus_proxy_call_sync(proxy,
+                "SetTimezone",
+                g_variant_new("(sb)",
+                    tz.c_str(),
+                    FALSE),
+                G_DBUS_CALL_FLAGS_NONE,
+                500,
+                nullptr,
+                nullptr);
+    }
+};
+
+#endif