Merge lp:~facundo/magicicada-gui/fake-dbus into lp:magicicada-gui

[Facundo Batista]

DBus refactoring.

Now all the dbus details are handled in a separate module/class, with its tests.

SyncDaemon now is a lot more simpler.

Zillion of test cases added and refactored.

[lp:~facundo/magicicada-gui/fake-dbus]

31. By Facundo Batista on 2010-05-26

Merged trunk in

32. By Facundo Batista on 2010-05-26

Changed where I log start

33. By Facundo Batista on 2010-05-27

Get initial data only when it should

34. By Facundo Batista on 2010-05-27

One more case

35. By Facundo Batista on 2010-05-27

Merged lp:~nataliabidart/magicicada/handle-items-none

36. By Facundo Batista on 2010-05-27

Initial callbacks

37. By Facundo Batista on 2010-05-27

Yes, we should put docstrings... but not twice!

[Natalia Bidart (nataliabidart)]

Very nice!

review: Approve

=== added file 'magicicada/dbusiface.py'
--- magicicada/dbusiface.py	1970-01-01 00:00:00 +0000
+++ magicicada/dbusiface.py	2010-05-27 20:56:26 +0000
@@ -0,0 +1,288 @@
+# dbusiface.py
+#
+# Author: Facundo Batista <[e-mail]>
+#
+# Copyright 2010 Chicharreros
+#
+# 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/>.
+
+"""The DBus Interface."""
+
+import collections
+import logging
+import re
+import sys
+
+import dbus
+from dbus import SessionBus
+from dbus.mainloop.glib import DBusGMainLoop
+
+from ubuntuone.syncdaemon.tools import SyncDaemonTool
+
+# log!
+logger = logging.getLogger('magicicada.dbusiface')
+handler = logging.StreamHandler(sys.stdout)
+logger.addHandler(handler)
+formatter = logging.Formatter("%(asctime)s %(name)s:%(lineno)-4d "
+                              "%(levelname)-8s %(message)s",
+                              '%Y-%m-%d %H:%M:%S')
+handler.setFormatter(formatter)
+logger.setLevel(logging.DEBUG)
+
+
+QueueData = collections.namedtuple('QueueData', 'operation path share node')
+FolderData = collections.namedtuple('FolderData',
+                                'node path suggested_path subscribed volume')
+
+# regular expressions for parsing MetaQueue data
+RE_OP_LISTDIR = re.compile("(ListDir)\(share_id=(.*?), node_id=(.*?), .*")
+RE_OP_UNLINK = re.compile("(Unlink)\(share_id=(.*?), node_id=(.*?), .*")
+RE_OP_MAKEFILE = re.compile(
+                "(MakeFile)\(share_id=(.*?), parent_id=(.*?), name=(.*?), .*")
+RE_OP_MAKEDIR = re.compile(
+                "(MakeDir)\(share_id=(.*?), parent_id=(.*?), name=(.*?), .*")
+RE_OP_MOVE = re.compile(
+                "(Move)\(share_id=(.*?), node_id=(.*?), old_parent_id=(.*?), "
+                "new_parent_id=(.*?), new_name=(.*?)\)")
+
+
+class DBusInterface(object):
+    """The DBus Interface to Ubuntu One's SyncDaemon."""
+
+    def __init__(self, msd):
+        # magicicada's syncdaemon
+        self.msd = msd
+        logger.info("DBus interface starting")
+
+        # set up dbus and related stuff
+        loop = DBusGMainLoop(set_as_default=True)
+        self._bus = bus = SessionBus(mainloop=loop)
+        self.sync_daemon_tool = SyncDaemonTool(bus)
+
+        # hook up for signals and store info for the shutdown
+        _signals = [
+            (self._on_status_changed, 'Status', 'StatusChanged'),
+            (self._on_content_queue_changed, 'Status', 'ContentQueueChanged'),
+            (self._on_name_owner_changed, None, 'NameOwnerChanged'),
+            (self._on_folder_created, 'Folders', 'FolderCreated'),
+            (self._on_folder_deleted, 'Folders', 'FolderDeleted'),
+        ]
+        self._dbus_matches = []
+        for method, dbus_lastname, signal_name in _signals:
+            if dbus_lastname is None:
+                dbus_interface = None
+            else:
+                dbus_interface = 'com.ubuntuone.SyncDaemon.' + dbus_lastname
+            match = bus.add_signal_receiver(method,
+                                            dbus_interface=dbus_interface,
+                                            signal_name=signal_name)
+            self._dbus_matches.append((match, dbus_interface, signal_name))
+
+
+    def shutdown(self):
+        """Shut down the SyncDaemon."""
+        logger.info("DBus interface going down")
+
+        # remove the signals from DBus
+        remove = self._bus.remove_signal_receiver
+        for match, dbus_interface, signal in self._dbus_matches:
+            remove(match, dbus_interface=dbus_interface, signal_name=signal)
+
+    def _process_status(self, state):
+        """Transform status information."""
+        name = state['name']
+        description = state['description']
+        is_error = bool(state['is_error'])
+        is_connected = bool(state['is_connected'])
+        is_online = bool(state['is_online'])
+        queues = state['queues']
+        connection = state['connection']
+        return (name, description, is_error, is_connected,
+                is_online, queues, connection)
+
+    def get_status(self):
+        """Gets SD status."""
+        logger.info("Getting status")
+        d = self.sync_daemon_tool.get_status()
+        d.addCallback(self._process_status)
+        return d
+
+    def _on_status_changed(self, state):
+        """Call the SD callback."""
+        logger.info("Received Status changed")
+        logger.debug("Status changed data: %r", state)
+        data = self._process_status(state)
+        self.msd.on_sd_status_changed(*data)
+
+    def _on_content_queue_changed(self, _):
+        """Call the SD callback."""
+        logger.info("Received Content Queue changed")
+        self.msd.on_sd_content_queue_changed()
+
+    def _on_name_owner_changed(self, name, oldowner, newowner):
+        """Receive the NameOwnerChanged signal from DBus."""
+        if name != 'com.ubuntuone.SyncDaemon':
+            return
+
+        logger.info("Received Name Owner changed")
+        logger.debug("Name Owner data: %r %r", oldowner, newowner)
+        old = bool(oldowner)
+        new = bool(newowner)
+        if old == new:
+            logger.error("Name Owner invalid data: Same bool in old and new!")
+            return
+        self.msd.on_sd_name_owner_changed(new)
+
+    def _on_folder_created(self, _):
+        """Call the SD callback."""
+        logger.info("Received Folder created")
+        self.msd.on_sd_folders_changed()
+
+    def _on_folder_deleted(self, _):
+        """Call the SD callback."""
+        logger.info("Received Folder deleted")
+        self.msd.on_sd_folders_changed()
+
+    def get_content_queue(self):
+        """Get the content queue from SDT."""
+        def process(data):
+            """Enhance data format."""
+            logger.info("Processing Content Queue items (%d)", len(data))
+            all_items = []
+            for d in data:
+                logger.debug("    Content Queue data: %r", d)
+                cq = QueueData(operation=d['operation'], path=d['path'],
+                               node=d['node'], share=d['share'])
+                all_items.append(cq)
+            return all_items
+
+        logger.info("Getting content queue")
+        d = self.sync_daemon_tool.waiting_content()
+        d.addCallback(process)
+        return d
+
+    def _parse_mq(self, data):
+        """Parse MetaQueue string to extract its data."""
+        if data in ('AccountInquiry', 'FreeSpaceInquiry', 'GetPublicFiles',
+                    'ListShares', 'ListVolumes', 'Query'):
+            return QueueData(operation=data, path=None, node=None, share=None)
+
+        m = RE_OP_LISTDIR.match(data)
+        if m:
+            op, share, node = m.groups()
+            path = '?' # we should get the real path, no API now
+            return QueueData(operation=op, path=path, node=node, share=share)
+
+        m = RE_OP_MAKEFILE.match(data)
+        if m:
+            op, share, parent, name = m.groups()
+            path = '/?.../' + name # we should get the real path, no API now
+            return QueueData(operation=op, path=path, node=None, share=share)
+
+        m = RE_OP_MAKEDIR.match(data)
+        if m:
+            op, share, parent, name = m.groups()
+            path = '/?.../' + name # we should get the real path, no API now
+            return QueueData(operation=op, path=path, node=None, share=share)
+
+        m = RE_OP_UNLINK.match(data)
+        if m:
+            op, share, node, = m.groups()
+            path = '?' # we should get the real path, no API now
+            return QueueData(operation=op, path=path, node=node, share=share)
+
+        m = RE_OP_MOVE.match(data)
+        if m:
+            op, share, node, old_parent, new_parent, new_name, = m.groups()
+
+            # we should get the real info, no API now
+            old_path = '/?...'
+            old_name = '?'
+            new_path = '/?...'
+            composed_path = "%s/%s -> %s/%s" % (old_path, old_name,
+                                                new_path, new_name)
+            return QueueData(operation=op, path=composed_path,
+                             node=node, share=share)
+
+        raise ValueError("Not supported MetaQueue data: %r" % data)
+
+    def get_meta_queue(self):
+        """Get the meta queue from SDT."""
+        def process(data):
+            """Enhance data format."""
+            logger.info("Processing Meta Queue items (%d)", len(data))
+            all_items = []
+            for d in data:
+                logger.debug("    Meta Queue data: %r", d)
+                parsed = self._parse_mq(d)
+                all_items.append(parsed)
+            return all_items
+
+        logger.info("Getting meta queue")
+        d = self.sync_daemon_tool.waiting_metadata()
+        d.addCallback(process)
+        return d
+
+    def get_folders(self):
+        """Get the folders info from SDT."""
+        def process(data):
+            """Enhance data format."""
+            logger.info("Processing Folders items (%d)", len(data))
+            all_items = []
+            for d in data:
+                logger.debug("    Folders data: %r", d)
+                f = FolderData(node=d['node_id'], path=d['path'],
+                               suggested_path=d['suggested_path'],
+                               volume=d['volume_id'],
+                               subscribed=bool(d['subscribed']))
+                all_items.append(f)
+            return all_items
+
+        logger.info("Getting folders")
+        d = self.sync_daemon_tool.get_folders()
+        d.addCallback(process)
+        return d
+
+    def start(self):
+        """Start SDT."""
+        logger.info("Calling start")
+        self.sync_daemon_tool.start()
+
+    def quit(self):
+        """Stop SDT."""
+        logger.info("Calling quit")
+        self.sync_daemon_tool.quit()
+
+    def connect(self):
+        """Connect SDT."""
+        logger.info("Calling connect")
+        self.sync_daemon_tool.connect()
+
+    def disconnect(self):
+        """Disconnect SDT."""
+        logger.info("Calling disconnect")
+        self.sync_daemon_tool.disconnect()
+
+    def is_sd_started(self):
+        """Find out if SD is active in the system."""
+        try:
+            self._bus.get_name_owner('com.ubuntuone.SyncDaemon')
+        except dbus.exceptions.DBusException, err:
+            if err.get_dbus_name() != \
+                                'org.freedesktop.DBus.Error.NameHasNoOwner':
+                raise
+            started = False
+        else:
+            started = True
+        logger.info("Checking if SD is started: %s", started)
+        return started

=== modified file 'magicicada/syncdaemon.py'
--- magicicada/syncdaemon.py	2010-05-23 10:23:35 +0000
+++ magicicada/syncdaemon.py	2010-05-27 20:56:26 +0000
@@ -18,17 +18,12 @@
 
 """The backend that communicates Magicicada with the SyncDaemon."""
 
-import collections
 import logging
-import re
 import sys
 
-import dbus
-from dbus.mainloop.glib import DBusGMainLoop
-from twisted.internet import reactor
-
-from ubuntuone.syncdaemon import tools
-
+from twisted.internet import defer, reactor
+
+from magicicada.dbusiface import DBusInterface
 from magicicada.helpers import NO_OP
 
 # log!
@@ -41,19 +36,6 @@
 handler.setFormatter(formatter)
 logger.setLevel(logging.DEBUG)
 
-# regular expressions for parsing MetaQueue data
-RE_OP_LISTDIR = re.compile("(ListDir)\(share_id=(.*?), node_id=(.*?), .*")
-RE_OP_UNLINK = re.compile("(Unlink)\(share_id=(.*?), node_id=(.*?), .*")
-RE_OP_MAKEFILE = re.compile(
-                "(MakeFile)\(share_id=(.*?), parent_id=(.*?), name=(.*?), .*")
-RE_OP_MAKEDIR = re.compile(
-                "(MakeDir)\(share_id=(.*?), parent_id=(.*?), name=(.*?), .*")
-RE_OP_MOVE = re.compile(
-                "(Move)\(share_id=(.*?), node_id=(.*?), old_parent_id=(.*?), "
-                "new_parent_id=(.*?), new_name=(.*?)\)")
-
-# structure that hold content and queue information
-QueueData = collections.namedtuple('QueueData', 'operation path share node')
 
 class State(object):
     """Holds the state of SD."""
@@ -96,29 +78,17 @@
 class SyncDaemon(object):
     """Interface to Ubuntu One's SyncDaemon."""
 
-    def __init__(self):
+    def __init__(self, dbus_class=DBusInterface):
+        logger.info("SyncDaemon interface started!")
+
         # set up dbus and related stuff
-        loop = DBusGMainLoop(set_as_default=True)
-        self._bus = bus = dbus.SessionBus(mainloop=loop)
-        self.sync_daemon_tool = tools.SyncDaemonTool(bus)
+        self.dbus = dbus_class(self)
+
+        # attributes for GUI, definition and filling
         self.current_state = State()
-
-        # hook up for signals and store info for the shutdown
-        _signals = [
-            (self._on_status_changed, 'Status', 'StatusChanged'),
-            (self._on_content_queue_changed, 'Status', 'ContentQueueChanged'),
-            (self._on_name_owner_changed, None, 'NameOwnerChanged'),
-        ]
-        self._dbus_matches = []
-        for method, dbus_lastname, signal_name in _signals:
-            if dbus_lastname is None:
-                dbus_interface = None
-            else:
-                dbus_interface = 'com.ubuntuone.SyncDaemon.' + dbus_lastname
-            match = bus.add_signal_receiver(method,
-                                            dbus_interface=dbus_interface,
-                                            signal_name=signal_name)
-            self._dbus_matches.append((match, dbus_interface, signal_name))
+        self.folders = None
+        self.content_queue = None
+        self.meta_queue = None
 
         # callbacks for GUI to hook in
         self.status_changed_callback = NO_OP
@@ -131,70 +101,69 @@
         self.on_online_callback = NO_OP
         self.on_offline_callback = NO_OP
 
-        # calls to obtain data from SDT
-        self._get_content_queue = self.sync_daemon_tool.waiting_content
-        self._get_meta_queue = self.sync_daemon_tool.waiting_metadata
-        self._do_start = self.sync_daemon_tool.start
-        self._do_quit = self.sync_daemon_tool.quit
-        self._do_connect = self.sync_daemon_tool.connect
-        self._do_disconnect = self.sync_daemon_tool.disconnect
-
-        # previous data
-        self._last_CQ_data = None
-        self._last_MQ_data = None
-
         # mq needs to be polled to know progress
         self._mqcaller = None
         self._mq_poll_time = 5   # seconds
 
-        # let's log!
-        logger.info("SyncDaemon interface started!")
+        # load initial data if ubuntuone-client already started
+        if self.dbus.is_sd_started():
+            self._get_initial_data()
 
 
     def shutdown(self):
         """Shut down the SyncDaemon."""
         logger.info("SyncDaemon interface going down")
-
-        # remove the signals from DBus
-        remove = self._bus.remove_signal_receiver
-        for match, dbus_interface, signal in self._dbus_matches:
-            remove(match, dbus_interface=dbus_interface, signal_name=signal)
+        self.dbus.shutdown()
 
         # cancel the mq polling caller, if any
         if self._mqcaller is not None and self._mqcaller.active():
             self._mqcaller.cancel()
 
-    def _on_name_owner_changed(self, name, oldowner, newowner):
-        """Receives the NameOwnerChanged signal from DBus."""
-        if name == 'com.ubuntuone.SyncDaemon':
-            logger.info("DBus informing about SD: old: %r  new: %r",
-                        oldowner, newowner)
-
-            old = bool(oldowner)
-            new = bool(newowner)
-            if old == new:
-                raise ValueError("Owners should have changed! Old: %r  "
-                                 "New: %r" % (oldowner, newowner))
-            self.current_state._set(is_started=new)
-            if new:
-                self.on_started_callback()
-            else:
-                self.on_stopped_callback()
-
-    def _on_status_changed(self, state):
-        """Receives the StatusChanged signal and send its data."""
-        logger.info("New status info from SD")
-        logger.debug("New status from SD: %r", state)
-
-        name = state['name']
-        description = state['description']
-        is_error = bool(state['is_error'])
-        is_connected = bool(state['is_connected'])
-        is_online = bool(state['is_online'])
-        queues = state['queues']
-        connection = state['connection']
-
-        # check status changes to call callbacks
+    @defer.inlineCallbacks
+    def _get_initial_data(self):
+        """Gets the initial SD data."""
+        logger.info("Getting initial data")
+
+        status_data = yield self.dbus.get_status()
+        self._send_status_changed(*status_data)
+
+        self.content_queue = yield self.dbus.get_content_queue()
+        self.content_queue_changed_callback(self.content_queue)
+
+        self.meta_queue = yield self.dbus.get_meta_queue()
+        self.meta_queue_changed_callback(self.meta_queue)
+
+        self.folders = yield self.dbus.get_folders()
+
+    @defer.inlineCallbacks
+    def on_sd_folders_changed(self):
+        """Folders changed, ask for new information."""
+        logger.info("SD Folders changed")
+        self.folders = yield self.dbus.get_folders()
+
+    def on_sd_name_owner_changed(self, now_active):
+        """SyncDaemon name owner changed."""
+        logger.info("SD Name Owner changed: %s", now_active)
+        self.current_state._set(is_started=now_active)
+        if now_active:
+            self.on_started_callback()
+            self._get_initial_data()
+        else:
+            self.on_stopped_callback()
+
+    def on_sd_status_changed(self, *status_data):
+        """The Status of SD changed.."""
+        logger.info("SD Status changed")
+        self._send_status_changed(*status_data)
+
+    def _send_status_changed(self, name, description, is_error, is_connected,
+                             is_online, queues, connection):
+        logger.debug("    new status: name=%r, description=%r, is_error=%s, "
+                     "is_connected=%s, is_online=%s, queues=%r, connection=%r",
+                     name, description, is_error, is_connected, is_online,
+                     queues, connection)
+
+        # check status changes to call other callbacks
         if is_connected and not self.current_state.is_connected:
             self.on_connected_callback()
         if not is_connected and self.current_state.is_connected:
@@ -204,168 +173,70 @@
         if not is_online and self.current_state.is_online:
             self.on_offline_callback()
 
-
         # set current state to new values and call status changed cb
-        self.current_state._set(**state)
-        self.status_changed_callback(name, description, is_error,
-                                     is_connected, is_online,
-                                     queues, connection)
+        self.current_state._set(name=name, description=description,
+                                is_error=is_error, is_connected=is_connected,
+                                is_online=is_online, queues=queues,
+                                connection=connection)
+        self.status_changed_callback(name, description, is_error, is_connected,
+                                     is_online, queues, connection)
 
         # if corresponds, supervise MQ
         self._check_mq()
 
-    def _generate_cq_info(self, data):
-        """Genereates an api friendly version of the data."""
-        all_items = []
-        for d in data:
-            logger.debug("Processing CQ data: %r", d)
-            cq = QueueData(operation=d['operation'], path=d['path'],
-                           node=d['node'], share=d['share'])
-            all_items.append(cq)
-        return all_items
-
-    @property
-    def content_queue(self):
-        """Returns the last known CQ info."""
-        if self._last_CQ_data is None:
-            return []
-        else:
-            return self._generate_cq_info(self._last_CQ_data)
-
-    def _process_cq(self, data):
-        """Processes ContentQueue data."""
-        # if same data than before, abort notification; else store it for later
-        logger.info("Processing CQ data")
-        if data == self._last_CQ_data:
-            return
-        self._last_CQ_data = data
-        logger.info("New CQ data to process")
-
-        all_items = self._generate_cq_info(data)
-        self.content_queue_changed_callback(all_items)
-
-    def _on_content_queue_changed(self, _):
-        """Receives the ContentQueueChanged signal and finds real data."""
-        logger.info("CQ changed in u1.SD!")
-
-        # get the info
-        d = self._get_content_queue()
-        d.addCallback(self._process_cq)
-
-    @property
-    def meta_queue(self):
-        """Returns the last known MQ info."""
-        if self._last_MQ_data is None:
-            return []
-        else:
-            all_items = []
-            for d in self._last_MQ_data:
-                all_items.append(self._parse_mq(d))
-            return all_items
-
-    def _parse_mq(self, data):
-        """Parse MetaQueue string to extract its data."""
-        if data in ('AccountInquiry', 'FreeSpaceInquiry', 'GetPublicFiles',
-                    'ListShares', 'ListVolumes', 'Query'):
-            return QueueData(operation=data, path=None, node=None, share=None)
-
-        m = RE_OP_LISTDIR.match(data)
-        if m:
-            op, share, node = m.groups()
-            path = '?' # we should get the real path, no API now
-            return QueueData(operation=op, path=path, node=node, share=share)
-
-        m = RE_OP_MAKEFILE.match(data)
-        if m:
-            op, share, parent, name = m.groups()
-            path = '/?.../' + name # we should get the real path, no API now
-            return QueueData(operation=op, path=path, node=None, share=share)
-
-        m = RE_OP_MAKEDIR.match(data)
-        if m:
-            op, share, parent, name = m.groups()
-            path = '/?.../' + name # we should get the real path, no API now
-            return QueueData(operation=op, path=path, node=None, share=share)
-
-        m = RE_OP_UNLINK.match(data)
-        if m:
-            op, share, node, = m.groups()
-            path = '?' # we should get the real path, no API now
-            return QueueData(operation=op, path=path, node=node, share=share)
-
-        m = RE_OP_MOVE.match(data)
-        if m:
-            op, share, node, old_parent, new_parent, new_name, = m.groups()
-
-            # we should get the real info, no API now
-            old_path = '/?...'
-            old_name = '?'
-            new_path = '/?...'
-            composed_path = "%s/%s -> %s/%s" % (old_path, old_name,
-                                                new_path, new_name)
-            return QueueData(operation=op, path=composed_path,
-                             node=node, share=share)
-
-        raise ValueError("Not supported MetaQueue data: %r" % data)
-
-    def _process_mq(self, data):
-        """Processes MetaQueue data."""
-        # if same data than before, abort notification; else store it for later
-        logger.info("Processing MQ data")
-        if data == self._last_MQ_data:
-            return
-        self._last_MQ_data = data
-        logger.info("New MQ data to process")
-
-        all_items = []
-        for d in data:
-            logger.debug("Processing MQ data: %r", d)
-            parsed = self._parse_mq(d)
-            logger.debug("            parsed: %s", parsed)
-            all_items.append(parsed)
-
-        self.meta_queue_changed_callback(all_items)
-
-    def _on_meta_queue_changed(self):
-        """Finds real data about meta queue."""
-        d = self._get_meta_queue()
-        d.addCallback(self._process_mq)
-
+    @defer.inlineCallbacks
+    def on_sd_content_queue_changed(self):
+        """Content Queue changed, ask for new information."""
+        logger.info("SD Content Queue changed")
+        new_cq = yield self.dbus.get_content_queue()
+        if new_cq != self.content_queue:
+            logger.info("Content Queue info is new! %d items", len(new_cq))
+            self.content_queue = new_cq
+            self.content_queue_changed_callback(new_cq)
+
+    @defer.inlineCallbacks
     def _check_mq(self):
         """Check MQ if we should."""
-        # check if we have something to show in MQ!
-        if self.current_state.name != 'QUEUE_MANAGER' or \
-           self.current_state.queues not in (
-                   'WORKING_ON_METADATA', 'WORKING_ON_BOTH'):
+        state = self.current_state
+        if state.name != 'QUEUE_MANAGER' or \
+           state.queues not in ('WORKING_ON_METADATA', 'WORKING_ON_BOTH'):
             logger.info("Check MQ called but States not in MQ")
-            return
-
-        # we have a previous call later running?
-        if self._mqcaller is not None and self._mqcaller.active():
-            self._mqcaller.cancel()
-
-        # get the info a programa
-        logger.info("Asking for MQ information")
-        d = self._get_meta_queue()
-        d.addCallback(self._process_mq)
-        self._mqcaller = reactor.callLater(self._mq_poll_time, self._check_mq)
+        else:
+            logger.info("Asking for MQ information")
+
+            # have we a previous call later still running?
+            if self._mqcaller is not None and self._mqcaller.active():
+                self._mqcaller.cancel()
+
+            # get the info
+            new_mq = yield self.dbus.get_meta_queue()
+
+            if new_mq != self.meta_queue:
+                logger.info("SD Meta Queue changed: %d items", len(new_mq))
+                self.meta_queue = new_mq
+                self.meta_queue_changed_callback(new_mq)
+
+            # check again later
+            self._mqcaller = reactor.callLater(self._mq_poll_time,
+                                               self._check_mq)
 
     def start(self):
         """Starts the SyncDaemon."""
         logger.info("Starting u1.SD")
-        self._do_start()
+        self.dbus.start()
+        self._get_initial_data()
 
     def quit(self):
         """Stops the SyncDaemon and makes it quit."""
         logger.info("Stopping u1.SD")
-        self._do_quit()
+        self.dbus.quit()
 
     def connect(self):
         """Tells the SyncDaemon that the user wants it to connect."""
         logger.info("Telling u1.SD to connect")
-        self._do_connect()
+        self.dbus.connect()
 
     def disconnect(self):
         """Tells the SyncDaemon that the user wants it to disconnect."""
         logger.info("Telling u1.SD to disconnect")
-        self._do_disconnect()
+        self.dbus.disconnect()

=== added file 'magicicada/tests/helpers.py'
--- magicicada/tests/helpers.py	1970-01-01 00:00:00 +0000
+++ magicicada/tests/helpers.py	2010-05-27 20:56:26 +0000
@@ -0,0 +1,49 @@
+# Helpers for the tessts
+#
+# Author: Facundo Batista <[e-mail]>
+#
+# Copyright 2010 Chicharreros
+#
+# 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/>.
+
+"""Helpers for the tests."""
+
+import logging
+
+
+class MementoHandler(logging.Handler):
+    """A handler class which store logging records in a list."""
+
+    def __init__(self, *args, **kwargs):
+        """Create the instance, and add a records attribute."""
+        logging.Handler.__init__(self, *args, **kwargs)
+        self.records = []
+
+    def emit(self, record):
+        """Just add the record to self.records."""
+        self.records.append(record)
+
+    def check(self, level, msg):
+        """Check that something is logged."""
+        for rec in self.records:
+            if rec.levelname == level and rec.message == msg:
+                return True
+        return False
+
+    def check_inf(self, msg):
+        """Shortcut for INFO check."""
+        return self.check('INFO', msg)
+
+    def check_dbg(self, msg):
+        """Shortcut for DEBUG check."""
+        return self.check('DEBUG', msg)

=== added file 'magicicada/tests/test_dbusiface.py'
--- magicicada/tests/test_dbusiface.py	1970-01-01 00:00:00 +0000
+++ magicicada/tests/test_dbusiface.py	2010-05-27 20:56:26 +0000
@@ -0,0 +1,665 @@
+# Tests for the DBus interface
+#
+# Author: Facundo Batista <[e-mail]>
+#
+# Copyright 2010 Chicharreros
+#
+# 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/>.
+
+"""Tests for the DBus interce towards real syncdaemon."""
+
+import logging
+
+import dbus
+from twisted.trial.unittest import TestCase as TwistedTestCase
+from twisted.internet import defer
+
+from magicicada import dbusiface
+from magicicada.tests.helpers import MementoHandler
+
+
+class FakeSessionBus(object):
+    """Fake Session Bus."""
+    def __init__(self, **kwargs):
+        self._callbacks = {}
+        self.fake_name_owner = "foo"
+
+    def add_signal_receiver(self, method, dbus_interface, signal_name):
+        """Add a signal receiver."""
+        self._callbacks[(dbus_interface, signal_name)] = method
+
+    def remove_signal_receiver(self, match, dbus_interface, signal_name):
+        """Remove the signal receiver."""
+        del self._callbacks[(dbus_interface, signal_name)]
+
+    def get_name_owner(self, name):
+        """Fakes the response of the method."""
+        assert name == 'com.ubuntuone.SyncDaemon'
+        if isinstance(self.fake_name_owner, str):
+            return self.fake_name_owner
+        else:
+            raise self.fake_name_owner
+
+
+class CallLoguer(object):
+    """Class that logs the methods called."""
+    def __init__(self):
+        self._called_method = None, ()
+        self._fake_response = None
+
+    def __getattribute__(self, name):
+        """Return the value if there."""
+        if name[0] == "_":
+            return object.__getattribute__(self, name)
+        else:
+            def f(*args):
+                setattr(self, "_called_method", (name, args))
+                if self._fake_response is None:
+                    # no hurt in returning a deferred, it may be needed
+                    return defer.Deferred()
+                methname, response = self._fake_response
+                assert methname == name
+                return response
+            return f
+
+
+class FakeSDTool(CallLoguer):
+    """Fake real SyncDaemonTool."""
+    def __init__(self, _):
+        CallLoguer.__init__(self)
+
+
+class FakeSyncDaemon(CallLoguer):
+    """Fake Magicicada's SyncDaemon."""
+
+
+class SafeTests(TwistedTestCase):
+    """Safe tests not going outside the testing box."""
+
+    def setUp(self):
+        """Set up."""
+        dbusiface.SessionBus = FakeSessionBus
+        dbusiface.SyncDaemonTool = FakeSDTool
+        self.fsd = FakeSyncDaemon()
+        self.dbus = dbusiface.DBusInterface(self.fsd)
+
+    def check_sdt_called(self, name):
+        """Check that the SyncDaemonTool method was called."""
+        self.assertEqual(self.dbus.sync_daemon_tool._called_method[0], name)
+
+    def get_msd_called(self, name):
+        """Get the args from the called Magicicada's SyncDaemon method."""
+        called_method, called_args = self.fsd._called_method
+        self.assertEqual(called_method, name)
+        return called_args
+
+    def fake_sdt_response(self, method_name, response):
+        """Fakes SDT answer in deferred mode."""
+        self.dbus.sync_daemon_tool._fake_response = (method_name,
+                                                     defer.succeed(response))
+
+class TestSignalHooking(SafeTests):
+    """Signal hooking tests.
+
+    We can not check if the methods are really called, because DBus holds the
+    method object itself, so no chance in monkeypatching.
+    """
+    def _get_hooked(self, iface, signal):
+        """Return the hooked method if any."""
+        if iface is None:
+            interface = None
+        else:
+            interface = 'com.ubuntuone.SyncDaemon.' + iface
+        return self.dbus._bus._callbacks.get((interface, signal))
+
+    def test_hook_unhook(self):
+        """Test the hooked signals are unhooked."""
+        self.dbus.shutdown()
+        self.assertEqual(self.dbus._bus._callbacks, {})
+
+    def test_status_changed(self):
+        """Test status changed callback."""
+        self.assertEqual(self._get_hooked('Status', 'StatusChanged'),
+                         self.dbus._on_status_changed)
+
+    def test_content_queue_changed(self):
+        """Test content queue changed callback."""
+        self.assertEqual(self._get_hooked('Status', 'ContentQueueChanged'),
+                         self.dbus._on_content_queue_changed)
+
+    def test_name_owner_changed(self):
+        """Test name owner changed callback."""
+        self.assertEqual(self._get_hooked(None, 'NameOwnerChanged'),
+                         self.dbus._on_name_owner_changed)
+
+    def test_folder_created_changed(self):
+        """Test folder created changed callback."""
+        self.assertEqual(self._get_hooked('Folders', 'FolderCreated'),
+                         self.dbus._on_folder_created)
+
+    def test_folder_deleted_changed(self):
+        """Test folder deleted changed callback."""
+        self.assertEqual(self._get_hooked('Folders', 'FolderDeleted'),
+                         self.dbus._on_folder_deleted)
+
+
+class TestSimpleCalls(SafeTests):
+    """Tests for some simple calls."""
+
+    @defer.inlineCallbacks
+    def test_is_sd_started_yes(self):
+        """Test is SD started, yes."""
+        self.dbus._bus.fake_name_owner = 'some owner'
+        resp = yield self.dbus.is_sd_started()
+        self.assertTrue(resp)
+
+    @defer.inlineCallbacks
+    def test_is_sd_started_no(self):
+        """Test is SD started, no."""
+        self.dbus._bus.fake_name_owner = dbus.exceptions.DBusException(
+                            name='org.freedesktop.DBus.Error.NameHasNoOwner')
+        resp = yield self.dbus.is_sd_started()
+        self.assertFalse(resp)
+
+
+class TestDataProcessingStatus(SafeTests):
+    """Processes Status before sending it to SyncDaemon."""
+
+    @defer.inlineCallbacks
+    def test_get_status(self):
+        """Test getting status."""
+        d = dict(name='n', description='d', is_error='', is_connected='True',
+                 is_online='', queues='q', connection='c')
+        self.fake_sdt_response('get_status', d)
+        args = yield self.dbus.get_status()
+        name, descrip, error, connected, online, queues, connection = args
+        self.assertEqual(name, 'n')
+        self.assertEqual(descrip, 'd')
+        self.assertEqual(error, False)
+        self.assertEqual(connected, True)
+        self.assertEqual(online, False)
+        self.assertEqual(queues, 'q')
+        self.assertEqual(connection, 'c')
+
+    def test_status_changed(self):
+        """Test status changed callback."""
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='', queues='queues',
+                 connection='connection')
+        self.dbus._on_status_changed(d)
+        args = self.get_msd_called("on_sd_status_changed")
+        name, descrip, error, connected, online, queues, connection = args
+        self.assertEqual(name, 'name')
+        self.assertEqual(descrip, 'description')
+        self.assertEqual(error, False)
+        self.assertEqual(connected, True)
+        self.assertEqual(online, False)
+        self.assertEqual(queues, 'queues')
+        self.assertEqual(connection, 'connection')
+
+
+class TestDataProcessingNameOwner(SafeTests):
+    """Processes Name Owner data before sending it to SyncDaemon."""
+
+    def test_name_owner_changed_no_syncdaemon(self):
+        """Test name owner changed callback."""
+        self.dbus._on_name_owner_changed("foo", "bar", "baz")
+        self.get_msd_called(None)
+
+    def test_name_owner_changed_yes_syncdaemon_TF(self):
+        """Test name owner changed callback."""
+        self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "T", "")
+        rcv, = self.get_msd_called("on_sd_name_owner_changed")
+        self.assertEqual(rcv, False)
+
+    def test_name_owner_changed_yes_syncdaemon_FT(self):
+        """Test name owner changed callback."""
+        self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "", "T")
+        rcv, = self.get_msd_called("on_sd_name_owner_changed")
+        self.assertEqual(rcv, True)
+
+
+class TestDataProcessingCQ(SafeTests):
+    """Processes CQ data before sending it to SyncDaemon."""
+
+    @defer.inlineCallbacks
+    def test_nodata(self):
+        """Test with no data in the queue."""
+        self.fake_sdt_response('waiting_content', [])
+        rcv = yield self.dbus.get_content_queue()
+        self.assertEqual(len(rcv), 0)
+
+    @defer.inlineCallbacks
+    def test_one_item(self):
+        """Test with one item in the queue."""
+        c = dict(operation='oper', path='path', share='share', node='node')
+        self.fake_sdt_response('waiting_content', [c])
+        rcv = yield self.dbus.get_content_queue()
+        self.assertEqual(len(rcv), 1)
+        data = rcv[0]
+        self.assertEqual(data.operation, 'oper')
+        self.assertEqual(data.path, 'path')
+        self.assertEqual(data.share, 'share')
+        self.assertEqual(data.node, 'node')
+
+    @defer.inlineCallbacks
+    def test_two_items(self):
+        """Test with two items in the queue."""
+        c = dict(operation='oper1', path='path1', share='share1', node='node1')
+        d = dict(operation='oper2', path='path2', share='share2', node='node2')
+        self.fake_sdt_response('waiting_content', [c, d])
+        rcv = yield self.dbus.get_content_queue()
+        self.assertEqual(len(rcv), 2)
+        data = rcv[0]
+        self.assertEqual(data.operation, 'oper1')
+        self.assertEqual(data.path, 'path1')
+        self.assertEqual(data.share, 'share1')
+        self.assertEqual(data.node, 'node1')
+        data = rcv[1]
+        self.assertEqual(data.operation, 'oper2')
+        self.assertEqual(data.path, 'path2')
+        self.assertEqual(data.share, 'share2')
+        self.assertEqual(data.node, 'node2')
+
+
+class TestDataProcessingMQ(SafeTests):
+    """Processes MQ data before sending it to SyncDaemon."""
+
+    @defer.inlineCallbacks
+    def test_nodata(self):
+        """Test with no data in the queue."""
+        self.fake_sdt_response('waiting_metadata', [])
+        rcv = yield self.dbus.get_meta_queue()
+        self.assertEqual(len(rcv), 0)
+
+    @defer.inlineCallbacks
+    def test_one_item(self):
+        """Test with one item in the queue."""
+        self.fake_sdt_response('waiting_metadata', ['ListShares'])
+        rcv = yield self.dbus.get_meta_queue()
+        self.assertEqual(len(rcv), 1)
+        data = rcv[0]
+        self.assertEqual(data.operation, 'ListShares')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_two_items(self):
+        """Test ContentQueueChanged signal with two items in the queue."""
+        cmd1 = 'MakeDir(share_id=a, parent_id=b, name=c, marker=d)'
+        cmd2 = 'GetPublicFiles'
+        self.fake_sdt_response('waiting_metadata', [cmd1, cmd2])
+        rcv = yield self.dbus.get_meta_queue()
+        self.assertEqual(len(rcv), 2)
+        data = rcv[0]
+        self.assertEqual(data.operation, 'MakeDir')
+        self.assertEqual(data.path, '/?.../c')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, None)
+        data = rcv[1]
+        self.assertEqual(data.operation, 'GetPublicFiles')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_GetPublicFiles(self):
+        """Test meta with GetPublicFiles."""
+        cmd = 'GetPublicFiles'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'GetPublicFiles')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_AccountInquiry(self):
+        """Test meta with AccountInquiry."""
+        cmd = 'AccountInquiry'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'AccountInquiry')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_FreeSpaceInquiry(self):
+        """Test meta with FreeSpaceInquiry."""
+        cmd = 'FreeSpaceInquiry'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'FreeSpaceInquiry')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_ListShares(self):
+        """Test meta with ListShares."""
+        cmd = 'ListShares'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'ListShares')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_ListVolumes(self):
+        """Test meta with ListVolumes."""
+        cmd = 'ListVolumes'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'ListVolumes')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_Query(self):
+        """Test meta with Query."""
+        cmd = 'Query'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'Query')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_ListDir(self):
+        """Test meta with ListDir."""
+        cmd = 'ListDir(share_id=a, node_id=b, server_hash=c)'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'ListDir')
+        self.assertEqual(data.path, '?')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, 'b')
+
+    @defer.inlineCallbacks
+    def test_MakeDir(self):
+        """Test meta with MakeDir."""
+        cmd = 'MakeDir(share_id=a, parent_id=b, name=c, marker=d)'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'MakeDir')
+        self.assertEqual(data.path, '/?.../c')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_MakeFile(self):
+        """Test meta with MakeFile."""
+        cmd = 'MakeFile(share_id=a, parent_id=b, name=c, marker=d)'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'MakeFile')
+        self.assertEqual(data.path, '/?.../c')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_Unlink(self):
+        """Test meta with Unlink."""
+        cmd = 'Unlink(share_id=a, node_id=b, server_hash=c)'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'Unlink')
+        self.assertEqual(data.path, '?')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, 'b')
+
+    @defer.inlineCallbacks
+    def test_Move(self):
+        """Test meta with Move."""
+        cmd = 'Move(share_id=a, node_id=b, old_parent_id=c, '\
+              'new_parent_id=d, new_name=e)'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'Move')
+        self.assertEqual(data.path, '/?.../? -> /?.../e')
+        self.assertEqual(data.share, 'a')
+        self.assertEqual(data.node, 'b')
+
+
+class TestDataProcessingFolders(SafeTests):
+    """Processes Folders data before sending it to SyncDaemon."""
+
+    @defer.inlineCallbacks
+    def test_nodata(self):
+        """Test get folders with no data."""
+        self.fake_sdt_response('get_folders', [])
+        rcv = yield self.dbus.get_folders()
+        self.assertEqual(len(rcv), 0)
+
+    @defer.inlineCallbacks
+    def test_one(self):
+        """Test get folders with one."""
+        d = dict(node_id='nid', path=u'pth', subscribed='True',
+                 suggested_path=u'sgp', type='UDF', volume_id='vid')
+        self.fake_sdt_response('get_folders', [d])
+        rcv = yield self.dbus.get_folders()
+        self.assertEqual(len(rcv), 1)
+        folder = rcv[0]
+        self.assertEqual(folder.node, 'nid')
+        self.assertEqual(folder.path, u'pth')
+        self.assertEqual(folder.suggested_path, u'sgp')
+        self.assertEqual(folder.subscribed, True)
+        self.assertEqual(folder.volume, 'vid')
+
+    @defer.inlineCallbacks
+    def test_getting_info_two(self):
+        """When changed, update info, got two."""
+        d1 = dict(node_id='nid1', path=u'pth1', subscribed='True',
+                  suggested_path=u'sgp1', type='UDF', volume_id='vid1')
+        d2 = dict(node_id='nid2', path=u'pth2', subscribed='',
+                  suggested_path=u'sgp2', type='UDF', volume_id='vid2')
+        self.fake_sdt_response('get_folders', [d1, d2])
+        rcv = yield self.dbus.get_folders()
+        self.assertEqual(len(rcv), 2)
+        folder = rcv[0]
+        self.assertEqual(folder.node, 'nid1')
+        self.assertEqual(folder.path, u'pth1')
+        self.assertEqual(folder.suggested_path, u'sgp1')
+        self.assertEqual(folder.subscribed, True)
+        self.assertEqual(folder.volume, 'vid1')
+        folder = rcv[1]
+        self.assertEqual(folder.node, 'nid2')
+        self.assertEqual(folder.path, u'pth2')
+        self.assertEqual(folder.suggested_path, u'sgp2')
+        self.assertEqual(folder.subscribed, False)
+        self.assertEqual(folder.volume, 'vid2')
+
+
+class TestToolActions(SafeTests):
+    """Actions against SD.tools.
+
+    Here we test only the actions, not callbacks, as they're tested before
+    in what they return.
+    """
+
+    def test_start(self):
+        """Test call to start."""
+        self.dbus.start()
+        self.check_sdt_called("start")
+
+    def test_quit(self):
+        """Test call to quit."""
+        self.dbus.quit()
+        self.check_sdt_called("quit")
+
+    def test_connect(self):
+        """Test call to connect."""
+        self.dbus.connect()
+        self.check_sdt_called("connect")
+
+    def test_disconnect(self):
+        """Test call to disconnect."""
+        self.dbus.disconnect()
+        self.check_sdt_called("disconnect")
+
+
+class TestLogs(SafeTests):
+    """Test logging."""
+
+    def setUp(self):
+        """Set up."""
+        self.handler = MementoHandler()
+        logging.getLogger('magicicada.dbusiface').addHandler(self.handler)
+        self.handler.setLevel(logging.DEBUG)
+        SafeTests.setUp(self)
+
+    def test_instancing(self):
+        """Just logged SD instancing."""
+        self.assertTrue(self.handler.check_inf("DBus interface starting"))
+
+    def test_shutdown(self):
+        """Log when SD shutdowns."""
+        self.dbus.shutdown()
+        self.assertTrue(self.handler.check_inf("DBus interface going down"))
+
+    def test_waiting_content(self):
+        """Test call to waiting content."""
+        self.dbus.get_content_queue()
+        self.assertTrue(self.handler.check_inf("Getting content queue"))
+
+    def test_waiting_meta(self):
+        """Test call to waiting meta."""
+        self.dbus.get_meta_queue()
+        self.assertTrue(self.handler.check_inf("Getting meta queue"))
+
+    def test_get_status(self):
+        """Test call to status."""
+        self.dbus.get_status()
+        self.assertTrue(self.handler.check_inf("Getting status"))
+
+    def test_get_folders(self):
+        """Test call to folders."""
+        self.dbus.get_folders()
+        self.assertTrue(self.handler.check_inf("Getting folders"))
+
+    def test_is_sd_started(self):
+        """Test call to is_sd_started."""
+        self.dbus.is_sd_started()
+        self.assertTrue(self.handler.check_inf(
+                        "Checking if SD is started: True"))
+
+    def test_start(self):
+        """Test call to start."""
+        self.dbus.start()
+        self.assertTrue(self.handler.check_inf("Calling start"))
+
+    def test_quit(self):
+        """Test call to quit."""
+        self.dbus.quit()
+        self.assertTrue(self.handler.check_inf("Calling quit"))
+
+    def test_connect(self):
+        """Test call to connect."""
+        self.dbus.connect()
+        self.assertTrue(self.handler.check_inf("Calling connect"))
+
+    def test_disconnect(self):
+        """Test call to disconnect."""
+        self.dbus.disconnect()
+        self.assertTrue(self.handler.check_inf("Calling disconnect"))
+
+    def test_status_changed(self):
+        """Test status changed callback."""
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='', queues='queues',
+                 connection='connection')
+        self.dbus._on_status_changed(d)
+        self.assertTrue(self.handler.check_inf("Received Status changed"))
+        self.assertTrue(self.handler.check_dbg("Status changed data: %r" % d))
+
+    def test_content_queue_changed(self):
+        """Test content queue changed callback."""
+        self.dbus._on_content_queue_changed("foo")
+        self.assertTrue(self.handler.check_inf(
+                        "Received Content Queue changed"))
+
+    def test_name_owner_changed_other(self):
+        """Test name owner changed callback, no SD."""
+        self.dbus._on_name_owner_changed("other", "", "T")
+        self.assertFalse(self.handler.check_inf("Received Name Owner changed"))
+
+    def test_name_owner_changed_syncdaemon(self):
+        """Test name owner changed callback, SD value ok."""
+        self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "", "T")
+        self.assertTrue(self.handler.check_inf("Received Name Owner changed"))
+        self.assertTrue(self.handler.check_dbg("Name Owner data: u'' u'T'"))
+
+    def test_name_owner_changed_yes_syncdaemon_TF(self):
+        """Test name owner changed callback, SD value bad."""
+        self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "F", "T")
+        self.assertTrue(self.handler.check_inf("Received Name Owner changed"))
+        self.assertTrue(self.handler.check_dbg("Name Owner data: u'F' u'T'"))
+        self.assertTrue(self.handler.check("ERROR",
+                        "Name Owner invalid data: Same bool in old and new!"))
+
+    def test_folder_created_changed(self):
+        """Test folder created changed callback."""
+        self.dbus._on_folder_created("foo")
+        self.assertTrue(self.handler.check_inf("Received Folder created"))
+
+    def test_folder_deleted_changed(self):
+        """Test folder deleted changed callback."""
+        self.dbus._on_folder_deleted("foo")
+        self.assertTrue(self.handler.check_inf("Received Folder deleted"))
+
+    @defer.inlineCallbacks
+    def test_content_queue_processing(self):
+        """Test with one item in the queue."""
+        c = dict(operation='oper', path='path', share='share', node='node')
+        self.fake_sdt_response('waiting_content', [c])
+        yield self.dbus.get_content_queue()
+        self.assertTrue(self.handler.check_inf(
+                        "Processing Content Queue items (1)"))
+        self.assertTrue(self.handler.check_dbg(
+                        "    Content Queue data: %s" % c))
+
+    @defer.inlineCallbacks
+    def test_meta_queue_processing(self):
+        """Test with one item in the queue."""
+        self.fake_sdt_response('waiting_metadata', ['ListShares'])
+        yield self.dbus.get_meta_queue()
+        self.assertTrue(self.handler.check_inf(
+                        "Processing Meta Queue items (1)"))
+        self.assertTrue(self.handler.check_dbg(
+                        "    Meta Queue data: u'ListShares'"))
+
+    @defer.inlineCallbacks
+    def test_folders_processing(self):
+        """Test get folders with one."""
+        d = dict(node_id='nid', path=u'pth', subscribed='True',
+                 suggested_path=u'sgp', type='UDF', volume_id='vid')
+        self.fake_sdt_response('get_folders', [d])
+        yield self.dbus.get_folders()
+        self.assertTrue(self.handler.check_inf("Processing Folders items (1)"))
+        self.assertTrue(self.handler.check_dbg("    Folders data: %r" % d))

=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-05-27 02:01:27 +0000
+++ magicicada/tests/test_magicicada.py	2010-05-27 20:56:26 +0000
@@ -25,6 +25,7 @@
 from twisted.trial.unittest import TestCase
 
 from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon
+from magicicada.dbusiface import QueueData
 from magicicada.helpers import NO_OP
 
 
@@ -278,9 +279,9 @@
         """Build some data to pass to queue changed callback and related."""
         items = []
         for i in xrange(limit):
-            cq = syncdaemon.QueueData(operation='operation %i' % i,
-                     path='path %i' % i, node='node %i' % i,
-                     share='share %i' % i)
+            cq = QueueData(operation='operation %i' % i,
+                           path='path %i' % i, node='node %i' % i,
+                           share='share %i' % i)
             items.append(cq)
         return items
 

=== modified file 'magicicada/tests/test_syncdaemon.py'
--- magicicada/tests/test_syncdaemon.py	2010-05-22 20:27:11 +0000
+++ magicicada/tests/test_syncdaemon.py	2010-05-27 20:56:26 +0000
@@ -21,49 +21,133 @@
 import logging
 import unittest
 
-import dbus
-from dbus.mainloop.glib import DBusGMainLoop
-
-# this should be imported *before* importing the reactor below, as needs to
-# install the glib connection first
 from magicicada.syncdaemon import SyncDaemon, State
-from magicicada.helpers import NO_OP
+from magicicada.tests.helpers import MementoHandler
 
-from dbus.lowlevel import SignalMessage
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from twisted.internet import defer, reactor
 
-from ubuntuone.syncdaemon.dbus_interface import DBUS_IFACE_STATUS_NAME
-
-
-class SignalsBaseTest(TwistedTestCase):
-    """Base infrastructure to tests the signals."""
-
-    timeout = 2
+
+class FakeDBusInterface(object):
+    """Fake DBus Interface, for SD to not use dbus at all during tests."""
+
+    fake_sd_started = False
+
+    def __init__(self, sd):
+        pass
+
+    def shutdown(self):
+        pass
+
+    def get_status(self):
+        """Fake status."""
+        return defer.succeed(('fakename', 'fakedescrip', False, True,
+                              False, 'fakequeues', 'fakeconnection'))
+    def get_folders(self):
+        """Fake folders."""
+        return defer.succeed('fakedata')
+    get_content_queue = get_meta_queue = get_folders
+    start = quit = connect = disconnect = get_folders
+
+    def is_sd_started(self):
+        """Fake response."""
+        return self.fake_sd_started
+
+
+class BaseTest(TwistedTestCase):
+    """Base test with a SD."""
+
+    timeout = 1
 
     def setUp(self):
-        """Set up the test."""
-        self.loop = DBusGMainLoop(set_as_default=True)
-        self.bus = dbus.bus.BusConnection(mainloop=self.loop)
-        self.sd = SyncDaemon()
+        """Set up."""
+        self.sd = SyncDaemon(FakeDBusInterface)
 
     def tearDown(self):
-        """Tear down the test."""
+        """Tear down."""
         self.sd.shutdown()
 
-    def send_signal(self, interface, signal, signature, *args):
-        """Send a DBus signal."""
-        msg = SignalMessage('/status', interface, signal)
-        msg.set_no_reply(True)
-        msg.append(*args, signature=signature)
-        self.bus.send_message(msg)
-
-
-class SimpleSignalsTests(SignalsBaseTest):
+
+class InitialDataTests(unittest.TestCase):
+    """Tests for initial data gathering."""
+
+    def test_called_by_start(self):
+        """Check that start calls get initial data."""
+        sd = SyncDaemon(FakeDBusInterface)
+        called = []
+        sd._get_initial_data = lambda: called.append(True)
+        sd.start()
+        self.assertTrue(called)
+
+    def test_called_by_nameownerchanged_no(self):
+        """Check that it is called when discover that sd started."""
+        sd = SyncDaemon(FakeDBusInterface)
+        called = []
+        sd._get_initial_data = lambda: called.append(True)
+        sd.on_sd_name_owner_changed(True)
+        self.assertTrue(called)
+
+    def test_called_by_nameownerchanged_yes(self):
+        """Check that it is not called when discover that sd stopped."""
+        sd = SyncDaemon(FakeDBusInterface)
+        called = []
+        sd._get_initial_data = lambda: called.append(True)
+        sd.on_sd_name_owner_changed(False)
+        self.assertFalse(called)
+
+    def test_called_beggining_no(self):
+        """Check that it should not be called if no SD."""
+        called = []
+        orig_met = SyncDaemon._get_initial_data
+        SyncDaemon._get_initial_data = lambda s: called.append(True)
+        SyncDaemon(FakeDBusInterface)
+        SyncDaemon._get_initial_data = orig_met
+        self.assertFalse(called)
+
+    def test_called_beggining_yes(self):
+        """Check that it should be called if SD already started."""
+        called = []
+        orig_met = SyncDaemon._get_initial_data
+        SyncDaemon._get_initial_data = lambda s: called.append(True)
+        FakeDBusInterface.fake_sd_started = True
+        SyncDaemon(FakeDBusInterface)
+        SyncDaemon._get_initial_data = orig_met
+        self.assertTrue(called)
+
+    def test_calls_callbacks(self):
+        """Check that initial data calls the callbacks for new data."""
+        called = []
+        sd = SyncDaemon(FakeDBusInterface)
+        f = lambda *a: called.append(True)
+        sd.status_changed_callback = f
+        sd.content_queue_changed_callback = f
+        sd.meta_queue_changed_callback = f
+
+        sd._get_initial_data()
+        self.assertEqual(len(called), 3)
+
+
+class StatusChangedTests(BaseTest):
     """Simple signals checking."""
 
+    @defer.inlineCallbacks
+    def test_initial_value(self):
+        """Fills the status info initially."""
+        called = []
+        def fake():
+            """Fake method."""
+            called.append(True)
+            return defer.succeed(('fakename', 'fakedescrip', False, True,
+                              False, 'fakequeues', 'fakeconnection'))
+
+        self.sd.dbus.get_status = fake
+        yield self.sd._get_initial_data()
+        self.assertTrue(called)
+
     def test_statuschanged(self):
         """Test StatusChanged signal."""
+        deferred = defer.Deferred()
+
         def callback(name, description, is_error, is_connected, is_online,
                      queues, connection):
             """Check received data."""
@@ -76,325 +160,208 @@
             self.assertEqual(connection, 'connection')
             deferred.callback(True)
 
-        # set the callback
         self.sd.status_changed_callback = callback
-
-        # send signal with signature and structures like original syncdaemon
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.send_signal(DBUS_IFACE_STATUS_NAME, 'StatusChanged', 'a{ss}', d)
-
-        deferred = defer.Deferred()
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
         return deferred
 
-
-class ContentQueueChangedTests(SignalsBaseTest):
+    def test_status_changed_affects_cuurent_status(self):
+        """Makes changes to see how status are reflected."""
+        # one set of values
+        self.sd.on_sd_status_changed('name1', 'description1', False, True,
+                                     False, 'queues1', 'connection1')
+        self.assertEqual(self.sd.current_state.name, 'name1')
+        self.assertEqual(self.sd.current_state.description, 'description1')
+        self.assertEqual(self.sd.current_state.is_error, False)
+        self.assertEqual(self.sd.current_state.is_connected, True)
+        self.assertEqual(self.sd.current_state.is_online, False)
+        self.assertEqual(self.sd.current_state.queues, 'queues1')
+        self.assertEqual(self.sd.current_state.connection, 'connection1')
+
+        # again, to be sure they actually are updated
+        self.sd.on_sd_status_changed('name2', 'description2', True, False,
+                                     True, 'queues2', 'connection2')
+        self.assertEqual(self.sd.current_state.name, 'name2')
+        self.assertEqual(self.sd.current_state.description, 'description2')
+        self.assertEqual(self.sd.current_state.is_error, True)
+        self.assertEqual(self.sd.current_state.is_connected, False)
+        self.assertEqual(self.sd.current_state.is_online, True)
+        self.assertEqual(self.sd.current_state.queues, 'queues2')
+        self.assertEqual(self.sd.current_state.connection, 'connection2')
+
+
+class ContentQueueChangedTests(BaseTest):
     """Check the ContenQueueChanged handling."""
 
+    @defer.inlineCallbacks
+    def test_initial_value(self):
+        """Fills the content queue info initially."""
+        called = []
+        self.sd.dbus.get_content_queue = lambda: called.append(True)
+        yield self.sd._get_initial_data()
+        self.assertTrue(called)
+
     def test_without_setting_callback(self):
         """It should work even if not hooking into the callback."""
-        self.sd._process_cq([])
-
-    def _contentqueuechanged_test(self, somedata):
-        """Test ContentQueueChanged signal with some data."""
-        def callback(queued_elements):
-            """Check received data."""
-            self.assertEqual(len(queued_elements), len(somedata))
-            for received, original in zip(queued_elements, somedata):
-                self.assertEqual(received.operation, original['operation'])
-                self.assertEqual(received.path, original['path'])
-                self.assertEqual(received.share, original['share'])
-                self.assertEqual(received.node, original['node'])
-            deferred.callback(True)
-
-        # set the callback
-        self.sd.content_queue_changed_callback = callback
-
-        # monkeypatch SyncDaemon to quickly return the queued elements
-        self.sd._get_content_queue = lambda: defer.succeed(somedata)
-
-        # send signal with signature and structures like original syncdaemon,
-        # but note that in this case we don't care of this info
-        data = {'foo': {'bar':'1', 'baz':'2'}}
-        self.send_signal(DBUS_IFACE_STATUS_NAME, 'ContentQueueChanged',
-                         'a{sa{ss}}', data)
-        deferred = defer.Deferred()
-        return deferred
-
-    def test_contentqueuechanged_nodata(self):
-        """Test ContentQueueChanged signal with no data in the queue."""
-        return self._contentqueuechanged_test([])
-
-    def test_contentqueuechanged_oneitem(self):
-        """Test ContentQueueChanged signal with one item in the queue."""
-        c = dict(operation='oper', path='path', share='share', node='node')
-        return self._contentqueuechanged_test([c])
-
-    def test_contentqueuechanged_twoitems(self):
-        """Test ContentQueueChanged signal with two items in the queue."""
-        c = dict(operation='oper1', path='path1', share='share1', node='node1')
-        d = dict(operation='oper2', path='path2', share='share2', node='node2')
-        return self._contentqueuechanged_test([c, d])
-
-    def test_no_double_callback_for_same_info(self):
-        """No callback call for same info in the CQ."""
-        callback_called = []
-        def callback(queued_elements):
-            """Store the callbacked stuff."""
-            callback_called.append(queued_elements)
-
-        # set the callback
-        self.sd.content_queue_changed_callback = callback
-
-        # data to test
-        c = dict(operation='oper1', path='path1', share='share1', node='node1')
-        d = dict(operation='oper2', path='path2', share='share2', node='node2')
-        e = dict(operation='oper3', path='path3', share='share3', node='node3')
-
-        # call a sequence of different and repeated data
-        self.sd._process_cq([c])
-        self.sd._process_cq([d])
-        self.sd._process_cq([d]) # repeated!
-        self.sd._process_cq([c])
-        self.sd._process_cq([e])
-        self.sd._process_cq([e]) # repeated!
-        self.sd._process_cq([e]) # repeated!
-        self.sd._process_cq([d])
-        self.sd._process_cq([d, d])
-        self.sd._process_cq([d, d]) # repeated!
-        self.sd._process_cq([d])
-        should_be = [ [c], [d], [c], [e], [d], [d, d], [d] ]
-
-        # check order and that it wasn't repeated
-        self.assertEqual(len(callback_called), len(should_be))
-        for cq_received, cq_original in zip(callback_called, should_be):
-            for received, original in zip(cq_received, cq_original):
-                self.assertEqual(received.operation, original['operation'])
-                self.assertEqual(received.path, original['path'])
-                self.assertEqual(received.share, original['share'])
-                self.assertEqual(received.node, original['node'])
-
-    def test_CQ_state_none(self):
-        """Check the ContentQueue info, being none."""
-        self.assertEqual(len(self.sd.content_queue), 0)
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+
+    def test_callback_call(self):
+        """Call the callback."""
+        called = []
+        self.sd.content_queue_changed_callback = lambda cq: called.append(cq)
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertTrue(called)
+
+    def test_callback_call_twice_different(self):
+        """Call the callback twice for different info."""
+        called = []
+        self.sd.content_queue_changed_callback = lambda cq: called.append(cq)
+
+        # first call
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(called, [['foo']])
+
+        # second call, different info
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['bar'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(called, [['foo'], ['bar']])
+
+    def test_callback_call_twice_same(self):
+        """Call the callback once, even getting twice the same info."""
+        called = []
+        self.sd.content_queue_changed_callback = lambda cq: called.append(cq)
+
+        # first call
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(called, [['foo']])
+
+        # second call, same info
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(called, [['foo']])
+
+    def test_CQ_state_nothing(self):
+        """Check the ContentQueue info, being nothing."""
+        self.sd.dbus.get_content_queue = lambda: defer.succeed([])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(self.sd.content_queue, [])
 
     def test_CQ_state_one(self):
         """Check the ContentQueue info, being one."""
-        d = dict(operation='oper', path='path', share='share', node='node')
-        self.sd._process_cq([d])
-        self.assertEqual(len(self.sd.content_queue), 1)
-
-        # check the data
-        cqit = self.sd.content_queue[0]
-        self.assertEqual(cqit.operation, 'oper')
-        self.assertEqual(cqit.path, 'path')
-        self.assertEqual(cqit.share, 'share')
-        self.assertEqual(cqit.node, 'node')
-
-    def test_CQ_state_several(self):
-        """Check the ContentQueue info, several calls, last one is bigger."""
-        c = dict(operation='oper1', path='path1', share='share1', node='node1')
-        d = dict(operation='oper2', path='path2', share='share2', node='node2')
-        self.sd._process_cq([c])
-        self.sd._process_cq([d])
-        self.sd._process_cq([c, d])
-        self.assertEqual(len(self.sd.content_queue), 2)
-
-        # check the data
-        cqit = self.sd.content_queue[0]
-        self.assertEqual(cqit.operation, 'oper1')
-        self.assertEqual(cqit.path, 'path1')
-        self.assertEqual(cqit.share, 'share1')
-        self.assertEqual(cqit.node, 'node1')
-        cqit = self.sd.content_queue[1]
-        self.assertEqual(cqit.operation, 'oper2')
-        self.assertEqual(cqit.path, 'path2')
-        self.assertEqual(cqit.share, 'share2')
-        self.assertEqual(cqit.node, 'node2')
-
-
-class MetaQueueChangedTests(SignalsBaseTest):
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(self.sd.content_queue, ['foo'])
+
+    def test_CQ_state_two(self):
+        """Check the ContentQueue info, two."""
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo', 'bar'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertEqual(self.sd.content_queue, ['foo', 'bar'])
+
+
+class MetaQueueChangedTests(BaseTest):
     """Check the MetaQueueChanged handling."""
 
-    def test_without_setting_callback(self):
-        """It should work even if not hooking into the callback."""
-        self.sd._process_mq([])
-
-    def _metaqueuechanged_test(self, inpdata, outdata):
-        """Test MetaQueueChanged signal with some data."""
-        deferred = defer.Deferred()
-        def callback(queued_elements):
-            """Check received data."""
-            self.assertEqual(len(queued_elements), len(outdata))
-            for received, original in zip(queued_elements, outdata):
-                self.assertEqual(received.operation, original['operation'])
-                self.assertEqual(received.path, original['path'])
-                self.assertEqual(received.share, original['share'])
-                self.assertEqual(received.node, original['node'])
-            deferred.callback(True)
-
-        # set the callback
-        self.sd.meta_queue_changed_callback = callback
-
-        # execute the function that trigger this (not by a dbus signal, as
-        # that was not available in Lucid)
-        self.sd._process_mq(inpdata)
-
-        return deferred
-
-    def test_metaqueuechanged_nodata(self):
-        """Test MetaQueueChanged signal with no data in the queue."""
-        return self._metaqueuechanged_test([], [])
-
-    def test_GetPublicFiles(self):
-        """Test meta with GetPublicFiles."""
-        r = dict(operation='GetPublicFiles', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['GetPublicFiles'], [r])
-
-    def test_AccountInquiry(self):
-        """Test meta with AccountInquiry."""
-        r = dict(operation='AccountInquiry', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['AccountInquiry'], [r])
-
-    def test_FreeSpaceInquiry(self):
-        """Test meta with FreeSpaceInquiry."""
-        r = dict(operation='FreeSpaceInquiry', path=None,
-                 share=None, node=None)
-        return self._metaqueuechanged_test(['FreeSpaceInquiry'], [r])
-
-    def test_ListShares(self):
-        """Test meta with ListShares."""
-        r = dict(operation='ListShares', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['ListShares'], [r])
-
-    def test_ListVolumes(self):
-        """Test meta with ListVolumes."""
-        r = dict(operation='ListVolumes', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['ListVolumes'], [r])
-
-    def test_Query(self):
-        """Test meta with Query."""
-        r = dict(operation='Query', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['Query'], [r])
-
-    def test_ListDir(self):
-        """Test meta with ListDir."""
-        r = dict(operation='ListDir', path='?', share='a', node='b')
-        cmd = 'ListDir(share_id=a, node_id=b, server_hash=c)'
-        return self._metaqueuechanged_test([cmd], [r])
-
-    def test_MakeDir(self):
-        """Test meta with MakeDir."""
-        r = dict(operation='MakeDir', path='/?.../c', share='a', node=None)
-        cmd = 'MakeDir(share_id=a, parent_id=b, name=c, marker=d)'
-        return self._metaqueuechanged_test([cmd], [r])
-
-    def test_MakeFile(self):
-        """Test meta with MakeFile."""
-        r = dict(operation='MakeFile', path='/?.../c', share='a', node=None)
-        cmd = 'MakeFile(share_id=a, parent_id=b, name=c, marker=d)'
-        return self._metaqueuechanged_test([cmd], [r])
-
-    def test_Unlink(self):
-        """Test meta with Unlink."""
-        r = dict(operation='Unlink', path='?', share='a', node='b')
-        cmd = 'Unlink(share_id=a, node_id=b, server_hash=c)'
-        return self._metaqueuechanged_test([cmd], [r])
-
-    def test_Move(self):
-        """Test meta with Move."""
-        r = dict(operation='Move', path='/?.../? -> /?.../e',
-                 share='a', node='b')
-        cmd = 'Move(share_id=a, node_id=b, old_parent_id=c, '\
-              'new_parent_id=d, new_name=e)'
-        return self._metaqueuechanged_test([cmd], [r])
-
-    def test_metaqueuechanged_twoitems(self):
-        """Test MetaQueueChanged signal with two items in the queue."""
-        r1 = dict(operation='AccountInquiry', path=None, share=None, node=None)
-        r2 = dict(operation='ListShares', path=None, share=None, node=None)
-        return self._metaqueuechanged_test(['AccountInquiry', 'ListShares'],
-                                           [r1, r2])
-
-    def test_no_double_callback_for_same_info(self):
-        """No callback call for same info in the MQ."""
-        callback_called = []
-        def callback(queued_elements):
-            """Store the callbacked stuff."""
-            callback_called.append(queued_elements)
-
-        # set the callback
-        self.sd.meta_queue_changed_callback = callback
-
-        # data to test
-        r1 = dict(operation='AccountInquiry', path=None, share=None, node=None)
-        cmd1 = 'AccountInquiry'
-        r2 = dict(operation='ListShares', path=None, share=None, node=None)
-        cmd2 = 'ListShares'
-        r3 = dict(operation='ListDir', path='?', share='a', node='b')
-        cmd3 = 'ListDir(share_id=a, node_id=b, server_hash=c)'
-
-        # call a sequence of different and repeated data
-        self.sd._process_mq([cmd1])
-        self.sd._process_mq([cmd2])
-        self.sd._process_mq([cmd2]) # repeated!
-        self.sd._process_mq([cmd1])
-        self.sd._process_mq([cmd3])
-        self.sd._process_mq([cmd3]) # repeated!
-        self.sd._process_mq([cmd3]) # repeated!
-        self.sd._process_mq([cmd2])
-        self.sd._process_mq([cmd2, cmd2])
-        self.sd._process_mq([cmd2, cmd2]) # repeated!
-        self.sd._process_mq([cmd2])
-        should_be = [ [r1], [r2], [r1], [r3], [r2], [r2, r2], [r2] ]
-
-        # check order and that it wasn't repeated
-        self.assertEqual(len(callback_called), len(should_be))
-        for cq_received, cq_original in zip(callback_called, should_be):
-            for received, original in zip(cq_received, cq_original):
-                self.assertEqual(received.operation, original['operation'])
-                self.assertEqual(received.path, original['path'])
-                self.assertEqual(received.share, original['share'])
-                self.assertEqual(received.node, original['node'])
+    def setUp(self):
+        """Set up."""
+        BaseTest.setUp(self)
+        self.sd.current_state._set(name='QUEUE_MANAGER',
+                                   queues='WORKING_ON_METADATA')
+
+    @defer.inlineCallbacks
+    def test_initial_value(self):
+        """Fills the meta queue info initially."""
+        called = []
+        self.sd.dbus.get_meta_queue = lambda: called.append(True)
+        yield self.sd._get_initial_data()
+        self.assertTrue(called)
+
+    def test_callback_call(self):
+        """Call the callback."""
+        called = []
+        self.sd.meta_queue_changed_callback = lambda mq: called.append(mq)
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd._check_mq()
+        self.assertTrue(called)
+
+    def test_callback_call_twice_different(self):
+        """Call the callback twice for different info."""
+        called = []
+        self.sd.meta_queue_changed_callback = lambda mq: called.append(mq)
+
+        # first call
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd._check_mq()
+        self.assertEqual(called, [['foo']])
+
+        # second call, different info
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['bar'])
+        self.sd._check_mq()
+        self.assertEqual(called, [['foo'], ['bar']])
+
+    def test_callback_call_twice_same(self):
+        """Call the callback once, even getting twice the same info."""
+        called = []
+        self.sd.meta_queue_changed_callback = lambda mq: called.append(mq)
+
+        # first call
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd._check_mq()
+        self.assertEqual(called, [['foo']])
+
+        # second call, same info
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd._check_mq()
+        self.assertEqual(called, [['foo']])
+
+    def test_polling_initiated_state_changed(self):
+        """The polling initiates when state changes."""
+        called = []
+        self.sd._check_mq = lambda: called.append(True)
+
+        # send some status changed
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
+        self.assertTrue(called)
 
     def test_mq_polling_workinginmetadata(self):
         """Check that it polls mq while working in metadata."""
-
         # set the callback
-        self.sd._get_meta_queue = lambda *a: deferred.callback(True)
-
-        # send signal with signature and structures like original syncdaemon
-        d = dict(name='QUEUE_MANAGER', queues='WORKING_ON_METADATA',
-                 description='description', is_error='', is_connected='True',
-                 is_online='', connection='conn')
-        self.send_signal(DBUS_IFACE_STATUS_NAME, 'StatusChanged', 'a{ss}', d)
-
         deferred = defer.Deferred()
+        def fake():
+            """Fake."""
+            deferred.callback(True)
+            return defer.succeed("foo")
+        self.sd.dbus.get_meta_queue = fake
+
+        # send status changed to working in metadata
+        self.sd.on_sd_status_changed('QUEUE_MANAGER', 'description', False,
+                                     True, False, 'WORKING_ON_METADATA',
+                                     'connection')
         return deferred
 
     def test_mq_polling_workinginboth(self):
         """Check that it polls mq while working in both."""
-
         # set the callback
-        self.sd._get_meta_queue = lambda *a: deferred.callback(True)
-
-        # send signal with signature and structures like original syncdaemon
-        d = dict(name='QUEUE_MANAGER', queues='WORKING_ON_BOTH',
-                 description='description', is_error='', is_connected='True',
-                 is_online='', connection='conn')
-        self.send_signal(DBUS_IFACE_STATUS_NAME, 'StatusChanged', 'a{ss}', d)
-
         deferred = defer.Deferred()
+        def fake():
+            """Fake."""
+            deferred.callback(True)
+            return defer.succeed("foo")
+        self.sd.dbus.get_meta_queue = fake
+
+        # send status changed to working in metadata
+        self.sd.on_sd_status_changed('QUEUE_MANAGER', 'description', False,
+                                     True, False, 'WORKING_ON_BOTH',
+                                     'connection')
         return deferred
 
     def test_mq_polling_untilfinish(self):
         """Check that it polls mq until no more is needed."""
-        # prepare different status changed signals
-        d1 = dict(name='QUEUE_MANAGER', queues='WORKING_ON_BOTH',
-                  description='description', is_error='', is_connected='True',
-                  is_online='', connection='conn')
-
         d2 = dict(name='QUEUE_MANAGER', queues='WORKING_ON_CONTENT',
                   description='description', is_error='', is_connected='True',
                   is_online='', connection='conn')
@@ -402,61 +369,47 @@
         # set the callback, and adjust the polling time to faster
         calls = []
         def fake_get(*a):
+            """Fake get."""
             calls.append(None)
             if len(calls) < 3:
                 pass  # no changes, should keep calling
             elif len(calls) == 3:
-                self.send_signal(DBUS_IFACE_STATUS_NAME,
-                                 'StatusChanged', 'a{ss}', d2)
+                self.sd.on_sd_status_changed('QUEUE_MANAGER', 'description',
+                                             False, True, False,
+                                             'WORKING_ON_CONTENT', 'connect')
+
                 # allow time to see if a mistaken call happens
                 reactor.callLater(.5, deferred.callback, True)
             else:
                 deferred.errback(ValueError("Too many calls"))
-            return defer.Deferred()
+            return defer.succeed("foo")
 
-        self.sd._get_meta_queue = fake_get
+        self.sd.dbus.get_meta_queue = fake_get
         self.sd._mq_poll_time = .1
 
-        self.send_signal(DBUS_IFACE_STATUS_NAME, 'StatusChanged', 'a{ss}', d1)
+        self.sd.on_sd_status_changed('QUEUE_MANAGER', 'description', False,
+                                     True, False, 'WORKING_ON_BOTH',
+                                     'connection')
         deferred = defer.Deferred()
         return deferred
 
-    def test_MQ_state_none(self):
-        """Check the MetaQueue info, being none."""
-        self.assertEqual(len(self.sd.meta_queue), 0)
+    def test_MQ_state_nothing(self):
+        """Check the MetaQueue info, being nothing."""
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed([])
+        self.sd._check_mq()
+        self.assertEqual(self.sd.meta_queue, [])
 
     def test_MQ_state_one(self):
         """Check the MetaQueue info, being one."""
-        self.sd._process_mq(['ListShares'])
-        self.assertEqual(len(self.sd.meta_queue), 1)
-
-        # check the data
-        mqit = self.sd.meta_queue[0]
-        self.assertEqual(mqit.operation, 'ListShares')
-        self.assertEqual(mqit.path, None)
-        self.assertEqual(mqit.share, None)
-        self.assertEqual(mqit.node, None)
-
-    def test_MQ_state_several(self):
-        """Check the MetaQueue info, several calls, last one is bigger."""
-        cmd1 = 'MakeDir(share_id=a, parent_id=b, name=c, marker=d)'
-        cmd2 = 'GetPublicFiles'
-        self.sd._process_mq([cmd1])
-        self.sd._process_mq([cmd2])
-        self.sd._process_mq([cmd1, cmd2])
-        self.assertEqual(len(self.sd.meta_queue), 2)
-
-        # check the data
-        mqit = self.sd.meta_queue[0]
-        self.assertEqual(mqit.operation, 'MakeDir')
-        self.assertEqual(mqit.path, '/?.../c')
-        self.assertEqual(mqit.share, 'a')
-        self.assertEqual(mqit.node, None)
-        mqit = self.sd.meta_queue[1]
-        self.assertEqual(mqit.operation, 'GetPublicFiles')
-        self.assertEqual(mqit.path, None)
-        self.assertEqual(mqit.share, None)
-        self.assertEqual(mqit.node, None)
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd._check_mq()
+        self.assertEqual(self.sd.meta_queue, ['foo'])
+
+    def test_MQ_state_two(self):
+        """Check the MetaQueue info, two."""
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo', 'bar'])
+        self.sd._check_mq()
+        self.assertEqual(self.sd.meta_queue, ['foo', 'bar'])
 
 
 class StateTests(unittest.TestCase):
@@ -519,95 +472,51 @@
         f = lambda *a, **k: setattr(self, 'called', True)
         setattr(obj, method_name, f)
 
-    def test_defaults_are_callable(self):
-        """Check the attributes are callable."""
-        meths = (self.sd._get_content_queue, self.sd._get_meta_queue,
-                 self.sd._do_start, self.sd._do_quit,
-                 self.sd._do_connect, self.sd._do_disconnect)
-        for meth in meths:
-            self.assertTrue(callable(meth), "Meth %r is not callable" % meth)
-
-    def test_is_connected_yes(self):
-        """Check is_connected, True."""
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        self.assertTrue(self.sd.current_state.is_connected)
-
-    def test_is_connected_no(self):
-        """Check is_connected, False."""
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        self.assertFalse(self.sd.current_state.is_connected)
-
-    def test_is_online_yes(self):
-        """Check is_online, True."""
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='True', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        self.assertTrue(self.sd.current_state.is_online)
-
-    def test_is_online_no(self):
-        """Check is_online, False."""
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        self.assertFalse(self.sd.current_state.is_online)
-
     def test_is_started_yes(self):
         """Check is_started, True."""
         # simulate the signal that indicates the name was registered
-        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', '', 'yes')
+        self.sd.on_sd_name_owner_changed(True)
         self.assertTrue(self.sd.current_state.is_started)
 
     def test_is_started_no(self):
         """Check is_started, False."""
-        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', 'yes', '')
+        self.sd.on_sd_name_owner_changed(False)
         self.assertFalse(self.sd.current_state.is_started)
 
     def test_start(self):
         """Test start calls SD."""
-        self.mpatch_called(self.sd, '_do_start')
+        self.mpatch_called(self.sd.dbus, 'start')
         self.sd.start()
         self.assertTrue(self.called)
 
     def test_quit(self):
         """Test quit calls SD."""
-        self.mpatch_called(self.sd, '_do_quit')
+        self.mpatch_called(self.sd.dbus, 'quit')
         self.sd.quit()
         self.assertTrue(self.called)
 
     def test_connect(self):
         """Test connect calls SD."""
-        self.mpatch_called(self.sd, '_do_connect')
+        self.mpatch_called(self.sd.dbus, 'connect')
         self.sd.connect()
         self.assertTrue(self.called)
 
     def test_disconnect(self):
         """Test disconnect calls SD."""
-        self.mpatch_called(self.sd, '_do_disconnect')
+        self.mpatch_called(self.sd.dbus, 'disconnect')
         self.sd.disconnect()
         self.assertTrue(self.called)
 
     def test_on_started(self):
         """Called when SD started."""
         self.flag_called(self.sd, 'on_started_callback')
-
-        # simulate the signal that indicates the name was registered
-        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', '', 'yes')
+        self.sd.on_sd_name_owner_changed(True)
         self.assertTrue(self.called)
 
     def test_on_stopped(self):
         """Called when SD stopped."""
         self.flag_called(self.sd, 'on_stopped_callback')
-
-        # simulate the signal that indicates the name was registered
-        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', 'yes', '')
+        self.sd.on_sd_name_owner_changed(False)
         self.assertTrue(self.called)
 
     def test_on_connected(self):
@@ -615,10 +524,8 @@
         self.flag_called(self.sd, 'on_connected_callback')
 
         # first signal with connected in True
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
         self.assertTrue(self.called)
 
     def test_on_disconnected(self):
@@ -626,12 +533,10 @@
         self.flag_called(self.sd, 'on_disconnected_callback')
 
         # connect and disconnect
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        d['is_connected'] = ''
-        self.sd._on_status_changed(d)
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
+        self.sd.on_sd_status_changed('name', 'description', False, False,
+                                     False, 'queues', 'connection')
         self.assertTrue(self.called)
 
     def test_on_online(self):
@@ -639,10 +544,8 @@
         self.flag_called(self.sd, 'on_online_callback')
 
         # first signal with online in True
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='True', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     True, 'queues', 'connection')
         self.assertTrue(self.called)
 
     def test_on_offline(self):
@@ -650,52 +553,23 @@
         self.flag_called(self.sd, 'on_offline_callback')
 
         # go online and then offline
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='True', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        d['is_online'] = ''
-        self.sd._on_status_changed(d)
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     True, 'queues', 'connection')
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
         self.assertTrue(self.called)
 
 
-class MementoHandler(logging.Handler):
-    """A handler class which store logging records in a list."""
-
-    def __init__(self, *args, **kwargs):
-        """Create the instance, and add a records attribute."""
-        logging.Handler.__init__(self, *args, **kwargs)
-        self.records = []
-
-    def emit(self, record):
-        """Just add the record to self.records."""
-        self.records.append(record)
-
-    def check(self, level, msg):
-        """Check that something is logged."""
-        for rec in self.records:
-            if rec.levelname == level and rec.message == msg:
-                return True
-        raise ValueError("Log not found (%s) %r" % (level, msg))
-
 
 class TestLogs(unittest.TestCase):
     """Test logging."""
 
     def setUp(self):
         """Set up."""
-        self.handler = MementoHandler()
-        logging.getLogger('magicicada.syncdaemon').addHandler(self.handler)
-        self.handler.setLevel(logging.DEBUG)
-        self.sd = SyncDaemon()
-
-        # don't use real SD!
-        self.sd._get_content_queue = lambda: defer.Deferred()
-        self.sd._get_meta_queue = lambda: defer.Deferred()
-        self.sd._do_start = NO_OP
-        self.sd._do_quit = NO_OP
-        self.sd._do_connect = NO_OP
-        self.sd._do_disconnect = NO_OP
+        self.hdlr = MementoHandler()
+        logging.getLogger('magicicada.syncdaemon').addHandler(self.hdlr)
+        self.hdlr.setLevel(logging.DEBUG)
+        self.sd = SyncDaemon(FakeDBusInterface)
 
     def tearDown(self):
         """Shut down!"""
@@ -703,100 +577,109 @@
 
     def test_instancing(self):
         """Just logged SD instancing."""
-        self.assertTrue(self.handler.check('INFO',
-                        "SyncDaemon interface started!"))
+        self.assertTrue(self.hdlr.check_inf("SyncDaemon interface started!"))
 
     def test_shutdown(self):
         """Log when SD shutdowns."""
         self.sd.shutdown()
-        self.assertTrue(self.handler.check('INFO',
-                        "SyncDaemon interface going down"))
+        self.assertTrue(self.hdlr.check_inf("SyncDaemon interface going down"))
+
+    @defer.inlineCallbacks
+    def test_initial_value(self):
+        """Log the initial filling."""
+        yield self.sd._get_initial_data()
+        self.assertTrue(self.hdlr.check_inf("Getting initial data"))
 
     def test_start(self):
         """Log the call to start."""
         self.sd.start()
-        self.assertTrue(self.handler.check('INFO',
-                        "Starting u1.SD"))
+        self.assertTrue(self.hdlr.check_inf("Starting u1.SD"))
 
     def test_quit(self):
         """Log the call to quit."""
         self.sd.quit()
-        self.assertTrue(self.handler.check('INFO',
-                        "Stopping u1.SD"))
+        self.assertTrue(self.hdlr.check_inf("Stopping u1.SD"))
 
     def test_connect(self):
         """Log the call to connect."""
         self.sd.connect()
-        self.assertTrue(self.handler.check('INFO',
-                        "Telling u1.SD to connect"))
+        self.assertTrue(self.hdlr.check_inf("Telling u1.SD to connect"))
 
     def test_disconnect(self):
         """Log the call to disconnect."""
         self.sd.disconnect()
-        self.assertTrue(self.handler.check('INFO',
-                        "Telling u1.SD to disconnect"))
+        self.assertTrue(self.hdlr.check_inf("Telling u1.SD to disconnect"))
 
     def test_check_mq_true(self):
         """Log the MQ check when it asks for info."""
         self.sd.current_state._set(name='QUEUE_MANAGER',
                                    queues='WORKING_ON_METADATA')
         self.sd._check_mq()
-        self.assertTrue(self.handler.check('INFO',
-                        "Asking for MQ information"))
+        self.assertTrue(self.hdlr.check_inf("Asking for MQ information"))
 
     def test_check_mq_noreally(self):
         """Log the MQ check when it should not work."""
         self.sd.current_state._set(name='QUEUE_MANAGER',
                                    queues='WORKING_ON_CONTENT')
         self.sd._check_mq()
-        self.assertTrue(self.handler.check('INFO',
+        self.assertTrue(self.hdlr.check_inf(
                         "Check MQ called but States not in MQ"))
 
-    def test_process_mq_called(self):
-        """Log that process_mq is called."""
-        self.sd._process_mq([])
-        self.assertTrue(self.handler.check('INFO', "Processing MQ data"))
-
-    def test_process_mq_new_data(self):
-        """Log that process_mq has new data."""
-        self.sd._process_mq(['AccountInquiry'])
-        self.assertTrue(self.handler.check('INFO', "New MQ data to process"))
-        self.assertTrue(self.handler.check('DEBUG',
-                        "Processing MQ data: u'AccountInquiry'"))
-        self.assertTrue(self.handler.check('DEBUG',
-                        "            parsed: QueueData(operation="
-                        "'AccountInquiry', path=None, share=None, node=None)"))
-
-    def test_process_cq_called(self):
-        """Log that process_cq is called."""
-        self.sd._process_cq([])
-        self.assertTrue(self.handler.check('INFO', "Processing CQ data"))
-
-    def test_process_cq_new_data(self):
+    def test_meta_queue_changed(self):
+        """Log that MQ has new data."""
+        self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
+        self.sd.current_state._set(name='QUEUE_MANAGER',
+                                   queues='WORKING_ON_METADATA')
+        self.sd._check_mq()
+        self.assertTrue(self.hdlr.check_inf("SD Meta Queue changed: 1 items"))
+
+    def test_content_queue_changed(self):
         """Log that process_cq has new data."""
-        c = dict(operation='op', path='pth', share='shr', node='n')
-        self.sd._process_cq([c])
-        self.assertTrue(self.handler.check('INFO', "New CQ data to process"))
-        self.assertTrue(self.handler.check('DEBUG',
-                                           "Processing CQ data: %r" % c))
+        self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
+        self.sd.on_sd_content_queue_changed()
+        self.assertTrue(self.hdlr.check_inf("SD Content Queue changed"))
+        self.assertTrue(self.hdlr.check_inf(
+                        "Content Queue info is new! 1 items"))
 
     def test_on_status_changed(self):
         """Log status changed."""
-        d = dict(name='name', description='description', is_error='',
-                 is_connected='True', is_online='', queues='queues',
-                 connection='connection')
-        self.sd._on_status_changed(d)
-        self.assertTrue(self.handler.check('INFO', "New status info from SD"))
-        self.assertTrue(self.handler.check('DEBUG',
-                                           "New status from SD: %r" % d))
+        self.sd.on_sd_status_changed('name', 'description', False, True,
+                                     False, 'queues', 'connection')
+        self.assertTrue(self.hdlr.check_inf("SD Status changed"))
+        self.assertTrue(self.hdlr.check_dbg("    new status: name=u'name', "
+            "description=u'description', is_error=False, is_connected=True, "
+            "is_online=False, queues=u'queues', connection=u'connection'"))
 
-    def test_on_content_queue_changed(self):
-        """Log content queue changed."""
-        self.sd._on_content_queue_changed(None)
-        self.assertTrue(self.handler.check('INFO', "CQ changed in u1.SD!"))
+    def test_folders_changed(self):
+        """Log when folders changed."""
+        self.sd.on_sd_folders_changed()
+        self.assertTrue(self.hdlr.check_inf("SD Folders changed"))
 
     def test_on_name_owner_changed(self):
         """Log name owner changed."""
-        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', 'old', '')
-        self.assertTrue(self.handler.check('INFO',
-                        "DBus informing about SD: old: u'old'  new: u''"))
+        self.sd.on_sd_name_owner_changed(True)
+        self.assertTrue(self.hdlr.check_inf("SD Name Owner changed: True"))
+
+
+class FoldersTests(BaseTest):
+    """Folders checking."""
+
+    def test_foldercreated_callback(self):
+        """Gets the new data after the folders changed."""
+        # set the callback
+        called = []
+        self.sd.dbus.get_folders = lambda: called.append(True)
+
+        # they changed!
+        self.sd.on_sd_folders_changed()
+
+        # test
+        self.assertTrue(called)
+
+    @defer.inlineCallbacks
+    def test_initial_value(self):
+        """Fills the folder info initially."""
+        called = []
+        self.sd.dbus.get_folders = lambda: called.append(True)
+        yield self.sd._get_initial_data()
+        self.assertTrue(called)