Merge lp:~thisfred/ubuntuone-client/fix-stale-notification-2-0 into lp:ubuntuone-client

[Eric Casteleijn]

Uploading filename is now reset on every message display.

Uploading filename is now reset on every message display.

[John O'Brien (jdobrien)]

Lots of conflicts. Can't really review until their merged.

review: Needs Fixing

Unmerged revisions

1145. By Eric Casteleijn on 2011-12-14

there, I fixed it

1144. By Eric Casteleijn on 2011-12-14

unchanged: attach bug

1143. By Alejandro J. Cura on 2011-12-13

Do a HEAD request on the server to get accurate timestamp (LP: #692597)

1142. By Natalia Bidart on 2011-11-08

- Make the Upload process do not close the tempfile until is finished
  (LP: #872924).
- Reset the tempfile on every Upload _run() (LP: #884959).

1141. By Facundo Batista on 2011-10-06

Fix filter by share and path (LP: #807737).

=== modified file 'tests/platform/linux/eventlog/test_zglog.py'
--- tests/platform/linux/eventlog/test_zglog.py	2011-10-27 11:39:43 +0000
+++ tests/platform/linux/eventlog/test_zglog.py	2011-12-14 21:48:23 +0000
@@ -25,7 +25,11 @@
 
 from distutils.spawn import find_executable
 
+<<<<<<< TREE
 from twisted.internet import defer
+=======
+from twisted.internet.defer import Deferred, inlineCallbacks
+>>>>>>> MERGE-SOURCE
 from zeitgeist.client import ZeitgeistClient
 from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation
 
@@ -92,7 +96,11 @@
 class ZeitgeistTestCase(DBusTwistedTestCase):
     """Tests for the zeitgeist logging module."""
 
+<<<<<<< TREE
     @defer.inlineCallbacks
+=======
+    @inlineCallbacks
+>>>>>>> MERGE-SOURCE
     def setUp(self):
         yield super(ZeitgeistTestCase, self).setUp()
         zgdaemon = find_executable("zeitgeist-daemon")

=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2011-11-30 19:30:00 +0000
+++ tests/platform/linux/test_dbus.py	2011-12-14 21:48:23 +0000
@@ -341,3 +341,1688 @@
             pass
         return d
     test_restart.skip = "leaves dbus stuff around, need to cleanup"
+<<<<<<< TREE
+=======
+
+
+class ConfigTests(DBusTwistedTestCase):
+    """Basic tests to the Config object exposed via D-Bus."""
+
+    def get_client(self):
+        """Return a Config DBusClient."""
+        return DBusClient(self.bus, '/config', DBUS_IFACE_CONFIG_NAME)
+
+    def test_get_throttling_limits(self):
+        """Test get_throttling_limits exposed method."""
+        client = self.get_client()
+        d = defer.Deferred()
+        aq = self.main.action_q
+        def reply_handler(result):
+            """Handle the reply."""
+            self.assertEquals(aq.readLimit, result['download'])
+            self.assertEquals(aq.writeLimit, result['upload'])
+            self.assertEquals(100, result['download'])
+            self.assertEquals(200, result['upload'])
+            d.callback(True)
+        def reply_handler_None(result):
+            """Handle the reply."""
+            self.assertEquals(-1, result['download'])
+            self.assertEquals(-1, result['upload'])
+            aq.readLimit = 100
+            aq.writeLimit = 200
+            client.call_method('get_throttling_limits',
+                               reply_handler=reply_handler,
+                               error_handler=self.error_handler)
+        client.call_method('get_throttling_limits',
+                           reply_handler=reply_handler_None,
+                           error_handler=self.error_handler)
+        return d
+
+
+    def test_set_throttling_limits(self):
+        """Test set_throttling_limits exposed method."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler(_):
+            """Handle the reply."""
+            aq = self.main.action_q
+            self.assertEquals(aq.readLimit, 100)
+            self.assertEquals(aq.writeLimit, 500)
+            d.callback(True)
+        client.call_method('set_throttling_limits', 100, 500,
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_enable_bandwidth_throttling(self):
+        """Test enable_bandwidth_throttling exposed method."""
+        client = self.get_client()
+        d = defer.Deferred()
+        aq = self.main.action_q
+        aq.throttling = False
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertTrue(aq.throttling_enabled)
+            d.callback(True)
+        client.call_method('enable_bandwidth_throttling',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_bandwidth_throttling(self):
+        """Test disable_bandwidth_throttling exposed method."""
+        client = self.get_client()
+        d = defer.Deferred()
+        aq = self.main.action_q
+        aq.throttling = True
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertFalse(aq.throttling_enabled)
+            d.callback(True)
+        client.call_method('disable_bandwidth_throttling',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_bandwidth_throttling_enabled(self):
+        """Test bandwidth_throttling_enabled exposed method."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertEquals(1, result)
+            d.callback(True)
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertEquals(0, result)
+            self.main.action_q.throttling_enabled = True
+            client.call_method('bandwidth_throttling_enabled',
+                               reply_handler=reply_handler_enabled,
+                               error_handler=self.error_handler)
+        client.call_method('bandwidth_throttling_enabled',
+                           reply_handler=reply_handler_disabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_udf_autosubscribe_enabled(self):
+        """Test for Config.udf_autosubscribe_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertFalse(result)
+            config.get_user_config().set_udf_autosubscribe(not result)
+            client.call_method('udf_autosubscribe_enabled',
+                               reply_handler=reply_handler_enabled,
+                               error_handler=self.error_handler)
+
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertTrue(result)
+            d.callback(True)
+
+        client.call_method('udf_autosubscribe_enabled',
+                           reply_handler=reply_handler_disabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_enable_udf_autosubscribe(self):
+        """Test for Config.enable_udf_autosubscribe."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertTrue(config.get_user_config().get_udf_autosubscribe())
+            d.callback(True)
+        client.call_method('enable_udf_autosubscribe',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_udf_autosubscribe(self):
+        """Test for Config.disable_udf_autosubscribe."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertFalse(config.get_user_config().get_udf_autosubscribe())
+            d.callback(True)
+        client.call_method('disable_udf_autosubscribe',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_share_autosubscribe_enabled(self):
+        """Test for Config.share_autosubscribe_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertFalse(result)
+            config.get_user_config().set_share_autosubscribe(not result)
+            client.call_method('share_autosubscribe_enabled',
+                               reply_handler=reply_handler_enabled,
+                               error_handler=self.error_handler)
+
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertTrue(result)
+            d.callback(True)
+
+        client.call_method('share_autosubscribe_enabled',
+                           reply_handler=reply_handler_disabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_enable_share_autosubscribe(self):
+        """Test for Config.enable_share_autosubscribe."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertTrue(config.get_user_config().get_share_autosubscribe())
+            d.callback(True)
+        client.call_method('enable_share_autosubscribe',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_share_autosubscribe(self):
+        """Test for Config.disable_share_autosubscribe."""
+        client = self.get_client()
+        d = defer.Deferred()
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertFalse(config.get_user_config().get_share_autosubscribe())
+            d.callback(True)
+        client.call_method('disable_share_autosubscribe',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_autoconnect_enabled(self):
+        """Test for Config.autoconnect_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertFalse(result)
+            config.get_user_config().set_autoconnect(not result)
+            d.callback(True)
+
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertTrue(result)
+            config.get_user_config().set_autoconnect(not result)
+            client.call_method('autoconnect_enabled',
+                               reply_handler=reply_handler_disabled,
+                               error_handler=self.error_handler)
+
+        client.call_method('autoconnect_enabled',
+                           reply_handler=reply_handler_enabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_enable_autoconnect(self):
+        """Test for Config.enable_autoconnect."""
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(config.get_user_config().set_autoconnect, orig)
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertTrue(config.get_user_config().get_autoconnect())
+            d.callback(True)
+
+        client.call_method('enable_autoconnect',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_autoconnect(self):
+        """Test for Config.disable_autoconnect."""
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(config.get_user_config().set_autoconnect, orig)
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertFalse(config.get_user_config().get_autoconnect())
+            d.callback(True)
+
+        client.call_method('disable_autoconnect',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_set_autoconnect_enabled(self):
+        """Test for Config.set_autoconnect_enabled.
+
+        DEPRECATED.
+
+        """
+        client = self.get_client()
+        d = defer.Deferred()
+        orig = config.get_user_config().get_autoconnect()
+        # restore autoconnect to original value
+        self.addCleanup(config.get_user_config().set_autoconnect, orig)
+
+        def reply_handler(_):
+            """Handle the reply."""
+            self.assertEqual(config.get_user_config().get_autoconnect(),
+                             not orig)
+            d.callback(True)
+
+        client.call_method('set_autoconnect_enabled', not orig,
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_show_all_notifications_enabled(self):
+        """Test for Config.show_all_notifications_enabled."""
+        client = self.get_client()
+        d = defer.Deferred()
+
+        def reply_handler_disabled(result):
+            """Handle the reply."""
+            self.assertTrue(result)
+            config.get_user_config().set_show_all_notifications(not result)
+            client.call_method('show_all_notifications_enabled',
+                               reply_handler=reply_handler_enabled,
+                               error_handler=self.error_handler)
+
+        def reply_handler_enabled(result):
+            """Handle the reply."""
+            self.assertFalse(result)
+            d.callback(True)
+
+        client.call_method('show_all_notifications_enabled',
+                           reply_handler=reply_handler_disabled,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_enable_show_all_notifications(self):
+        """Test for Config.enable_show_all_notifications."""
+        client = self.get_client()
+        d = defer.Deferred()
+        self.main.status_listener.show_all_notifications = False
+        def reply_handler(_):
+            """Handle the reply."""
+            user_config = config.get_user_config()
+            self.assertTrue(user_config.get_show_all_notifications())
+            self.assertTrue(self.main.status_listener.show_all_notifications)
+            d.callback(True)
+        client.call_method('enable_show_all_notifications',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_disable_show_all_notifications(self):
+        """Test for Config.disable_show_all_notifications."""
+        client = self.get_client()
+        d = defer.Deferred()
+        self.main.status_listener.show_all_notifications = True
+        def reply_handler(_):
+            """Handle the reply."""
+            user_config = config.get_user_config()
+            self.assertFalse(user_config.get_show_all_notifications())
+            self.assertFalse(self.main.status_listener.show_all_notifications)
+            d.callback(True)
+        client.call_method('disable_show_all_notifications',
+                           reply_handler=reply_handler,
+                           error_handler=self.error_handler)
+        return d
+
+
+class DBusOAuthTestCase(BaseTwistedTestCase):
+    """Tests the interaction between dbus_interface and credentials.
+
+    Check conditions when autconnecting is False.
+
+    """
+
+    timeout = 2
+    method = 'register'
+    autoconnecting = False
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Init."""
+        yield super(DBusOAuthTestCase, self).setUp()
+        self.events = []
+        self.patch(DBusInterface, 'test', True)
+        self.patch(dbus, 'Interface', FakedSSOBackend)
+        self.patch(dbus.service, 'BusName', FakedBusName)
+        self.bus = FakedSessionBus()
+
+        self.data_dir = self.mktemp('data_dir')
+        self.partials_dir = self.mktemp('partials')
+        self.root_dir = self.mktemp('root_dir')
+        self.shares_dir = self.mktemp('shares_dir')
+        self.main = FakeMain(self.root_dir, self.shares_dir,
+                             self.data_dir, self.partials_dir)
+        self.dbus_iface = DBusInterface(bus=self.bus, main=self.main,
+                                        system_bus=None, send_events=False)
+        self.dbus_iface.event_queue.push = lambda name, **kw: \
+                                           self.events.append((name, kw))
+        self.memento = MementoHandler()
+        logger.addHandler(self.memento)
+        self.addCleanup(logger.removeHandler, self.memento)
+
+    @defer.inlineCallbacks
+    def tearDown(self, *args):
+        """Shutdown."""
+        self.main.shutdown()
+        yield super(DBusOAuthTestCase, self).tearDown()
+
+    @defer.inlineCallbacks
+    def test_signals_are_connected(self):
+        """Dbus signals have connected handlers."""
+
+        def f(*a, **kw):
+            """Just succeed."""
+            self.assertIn((DBUS_CREDENTIALS_IFACE, None), self.bus.callbacks)
+            cb = self.bus.callbacks[(DBUS_CREDENTIALS_IFACE, None)]
+            self.assertEqual(self.dbus_iface._signal_handler, cb)
+            self.dbus_iface._deferred.callback(None)
+
+        self.patch(FakedSSOBackend, self.method, f)
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+
+    @defer.inlineCallbacks
+    def test_signals_are_removed_after_connection(self):
+        """Dbus signals are removed after connection."""
+
+        def f(*a, **kw):
+            """Just succeed."""
+            self.dbus_iface._deferred.callback(None)
+
+        self.patch(FakedSSOBackend, self.method, f)
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        self.assertNotIn((DBUS_CREDENTIALS_IFACE, None), self.bus.callbacks)
+
+    @defer.inlineCallbacks
+    def test_connect_pushes_SYS_USER_CONNECT_with_the_token(self):
+        """On connect, the event SYS_USER_CONNECT is pushed."""
+
+        def f(*a, **kw):
+            """Receive credentials."""
+            self.dbus_iface._signal_handler(FAKED_CREDENTIALS,
+                                            member='CredentialsFound')
+
+        self.patch(FakedSSOBackend, self.method, f)
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        self.assertEqual(self.events, [('SYS_USER_CONNECT',
+                                       {'access_token': FAKED_CREDENTIALS})])
+
+    @defer.inlineCallbacks
+    def test_connect_raises_NoAccessToken_if_no_token(self):
+        """If no credentials, NoAccessToken is raised."""
+
+        def f(*a, **kw):
+            """Receive error signal."""
+            self.dbus_iface._signal_handler({'error_type': 'Error description',
+                                             'error_detail': 'Detailed error'},
+                                            member='CredentialsError')
+
+        self.patch(FakedSSOBackend, self.method, f)
+        d = self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        d.addErrback(lambda failure: self.assertEqual(NoAccessToken,
+                                                      failure.type))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_connect_raises_NoAccessToken_if_auth_denied(self):
+        """If no credentials, NoAccessToken if user denied auth."""
+
+        def f(*a, **kw):
+            """Receive error signal."""
+            self.dbus_iface._signal_handler(member='AuthorizationDenied')
+
+        self.patch(FakedSSOBackend, self.method, f)
+        d = self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        d.addErrback(lambda failure: self.assertEqual(NoAccessToken,
+                                                      failure.type))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_connect_raises_NoAccessToken_if_no_creds(self):
+        """If no credentials, NoAccessToken if no credentials."""
+
+        def f(*a, **kw):
+            """Receive error signal."""
+            self.dbus_iface._signal_handler(member='CredentialsNotFound')
+
+        self.patch(FakedSSOBackend, self.method, f)
+        d = self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        d.addErrback(lambda failure: self.assertEqual(NoAccessToken,
+                                                      failure.type))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_dbus_exceptions_are_handled(self):
+        """Every DbusException is handled."""
+        expected = exceptions.DBusException('test me')
+
+        def f(*a, **kw):
+            """Just fail."""
+            raise expected
+
+        self.patch(FakedSSOBackend, self.method, f)
+        d = self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        d.addErrback(lambda failure: self.assertEqual(expected, failure.value))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_other_exceptions_are_logged_and_re_raised(self):
+        """Every other Exception is logged and re raised."""
+        expected = TypeError('test me')
+
+        def f(*a, **kw):
+            """Just fail."""
+            raise expected
+
+        self.patch(FakedSSOBackend, self.method, f)
+        d = self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        d.addErrback(lambda failure: self.assertEqual(expected, failure.value))
+        yield d
+        self.assertTrue(len(self.memento.records) > 0)
+        record = self.memento.records[1]
+        msg = record.message
+        self.assertIn('connect failed while getting the token', msg)
+        self.assertIn(expected, record.exc_info)
+
+    def test_oauth_credentials_are_none_at_startup(self):
+        """If the oauth_credentials are not passed as param, they are None."""
+        self.assertTrue(self.dbus_iface.oauth_credentials is None)
+
+    @defer.inlineCallbacks
+    def test_oauth_credentials_are_used_to_connect(self):
+        """If present, the oauth_credentials are used to connect."""
+        expected = {'consumer_key': 'ubuntuone',
+                    'consumer_secret': 'hammertime',
+                    'token': 'faked_token',
+                    'token_secret': 'faked_token_secret'}
+        self.dbus_iface.oauth_credentials = (expected['token'],
+                                             expected['token_secret'])
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        self.assertEqual(self.events, [('SYS_USER_CONNECT',
+                                       {'access_token': expected})])
+
+    @defer.inlineCallbacks
+    def test_oauth_credentials_can_be_a_four_uple(self):
+        """If present, the oauth_credentials are used to connect."""
+        expected = {'consumer_key': 'faked_consumer_key',
+                    'consumer_secret': 'faked_consumer_secret',
+                    'token': 'faked_token',
+                    'token_secret': 'faked_token_secret'}
+        self.dbus_iface.oauth_credentials = (expected['consumer_key'],
+                                             expected['consumer_secret'],
+                                             expected['token'],
+                                             expected['token_secret'])
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        self.assertEqual(self.events, [('SYS_USER_CONNECT',
+                                       {'access_token': expected})])
+
+    @defer.inlineCallbacks
+    def test_log_warning_if_oauth_credentials_len_is_useless(self):
+        """Log a warning and return if the oauth_credentials are useless."""
+        self.dbus_iface.oauth_credentials = ('consumer_key',
+                                             'consumer_secret',
+                                             'token_secret')
+        yield self.dbus_iface.connect(autoconnecting=self.autoconnecting)
+        self.assertEqual(self.events, [])
+        msgs = (str(self.dbus_iface.oauth_credentials), 'useless')
+        self.assertTrue(self.memento.check_warning(*msgs))
+
+    def test_signal_handler_remains_generic(self):
+        """The signal handler function should be generic."""
+        self.dbus_iface._signal_handler()
+        # no failure
+        self.assertTrue(self.memento.check_debug('member: None'))
+
+        self.dbus_iface._signal_handler(no_member_kwarg='Test')
+        # no failure
+        self.assertTrue(self.memento.check_debug('member: None'))
+
+
+class DBusOAuthTestCaseRegister(DBusOAuthTestCase):
+    """Tests the interaction between dbus_interface and credentials.
+
+    Check conditions when autconnecting is True.
+
+    """
+
+    method = 'find_credentials'
+    autoconnecting = True
+
+
+class FolderTests(DBusTwistedTestCase):
+    """Tests for the Folder object exposed via dbus."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup the test."""
+        yield super(FolderTests, self).setUp()
+        self.home_dir = self.mktemp('ubuntuonehacker')
+        self.folders_client = DBusClient(self.bus, '/folders',
+                                         DBUS_IFACE_FOLDERS_NAME)
+        self._old_home = os.environ['HOME']
+        os.environ['HOME'] = self.home_dir
+
+    @defer.inlineCallbacks
+    def tearDown(self):
+        os.environ['HOME'] = self._old_home
+        yield super(FolderTests, self).tearDown()
+
+    def _create_udf(self, id, node_id, suggested_path, subscribed=True):
+        """Create an UDF and returns it and the volume."""
+        path = get_udf_path(suggested_path)
+        # make sure suggested_path is unicode
+        if isinstance(suggested_path, str):
+            suggested_path = suggested_path.decode('utf-8')
+        udf = UDF(str(id), str(node_id), suggested_path, path, subscribed)
+        return udf
+
+    def testget_udf_dict(self):
+        """Test for Folders.get_udf_dict."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=False)
+        udf_dict = get_udf_dict(udf)
+        # check the path it's unicode
+        self.assertEquals(udf_dict['path'], udf.path.decode('utf-8'))
+        self.assertEquals(udf_dict['volume_id'], udf.id)
+        self.assertEquals(udf_dict['suggested_path'], udf.suggested_path)
+        self.assertEquals(udf_dict['node_id'], udf.node_id)
+        self.assertFalse(udf_dict['subscribed'])
+
+    def testget_udf_dict_bad_encoding(self):
+        """Test for Folders.get_udf_dict."""
+        suggested_path = u'~/Música'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=False)
+        udf.suggested_path = udf.suggested_path.encode('utf-8')
+        udf_dict = get_udf_dict(udf)
+        # check the path it's unicode
+        self.assertEquals(udf_dict['path'], udf.path.decode('utf-8'))
+        self.assertEquals(udf_dict['volume_id'], udf.id)
+        self.assertEquals(repr(udf_dict['suggested_path']),
+                          repr(udf.suggested_path.decode('utf-8')))
+        self.assertEquals(udf_dict['node_id'], udf.node_id)
+        self.assertFalse(udf_dict['subscribed'])
+
+    @defer.inlineCallbacks
+    def test_get_folders(self):
+        """Test for Folders.get_folders."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
+        d = defer.Deferred()
+        self.folders_client.call_method('get_folders',
+                                        reply_handler=d.callback,
+                                        error_handler=self.error_handler)
+        info = yield d
+        self.assertEquals(len(info), 0)
+        # add a udf
+        yield self.main.vm.add_udf(udf)
+        d2 = defer.Deferred()
+        self.folders_client.call_method('get_folders',
+                                        reply_handler=d2.callback,
+                                        error_handler=self.error_handler)
+        info = yield d2
+        udf_dict = get_udf_dict(self.main.vm.get_volume(udf.volume_id))
+        self.assertEquals(1, len(info))
+        for key, value in udf_dict.items():
+            self.assertEquals(info[0][key], value)
+
+    def test_get_info(self):
+        """Test for Folders.get_info."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
+        d = defer.Deferred()
+        self.folders_client.call_method('get_info', udf.path,
+                                        reply_handler=self.error_handler,
+                                        error_handler=d.callback)
+        def check_error(f):
+            """Check we get an error."""
+            # check the error type
+            self.assertEquals('org.freedesktop.DBus.Python.KeyError',
+                              f._dbus_error_name)
+            # add a udf
+            add_deferred = self.main.vm.add_udf(udf)
+            def get_info(_):
+                """Call get_info once we created the udf."""
+                d = defer.Deferred()
+                self.folders_client.call_method('get_info', udf.path,
+                                            reply_handler=d.callback,
+                                            error_handler=self.error_handler)
+                return d
+            add_deferred.addCallback(get_info)
+            return add_deferred
+        def check(info):
+            """Check we get the udf info."""
+            udf_dict = get_udf_dict(self.main.vm.get_volume(udf.volume_id))
+            self.assertEquals(info, udf_dict)
+        d.addCallback(check_error)
+        d.addCallback(check)
+        return d
+
+    def test_create(self):
+        """Test for Folders.create."""
+        path = os.path.join(self.home_dir, u'ñoño/'.encode('utf-8'))
+        id = uuid.uuid4()
+        node_id = uuid.uuid4()
+        d = defer.Deferred()
+        # patch AQ.create_udf
+        def create_udf(path, name, marker):
+            """Fake create_udf."""
+            # check that the marker it's the full path to the udf
+            udf_path = os.path.join(os.path.expanduser(path.encode('utf-8')), name.encode('utf-8'))
+            if str(marker) != udf_path:
+                d.errback(ValueError("marker != path - "
+                                     "marker: %r path: %r" % (marker, udf_path)))
+            self.main.event_q.push("AQ_CREATE_UDF_OK", volume_id=id,
+                                   node_id=node_id, marker=marker)
+        self.main.action_q.create_udf = create_udf
+        def created_handler(info):
+            """FolderCreated handler."""
+            d.callback(info)
+        match = self.bus.add_signal_receiver(created_handler,
+                                             signal_name='FolderCreated')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('create', path,
+                                        reply_handler=lambda *agrs: None,
+                                        error_handler=self.error_handler)
+        def check(info):
+            """Check the FolderCreated info."""
+            self.assertTrue(os.path.exists(info['path'].encode('utf-8')),
+                            info['path'].encode('utf-8'))
+            self.assertEquals(info['path'].encode('utf-8'),
+                              os.path.normpath(path))
+            mdobj = self.main.fs.get_by_path(path)
+            udf = self.main.vm.get_volume(mdobj.share_id)
+            self.assertNotEqual(None, udf)
+            self.assertEquals(udf.path, os.path.normpath(path))
+            udf_dict = get_udf_dict(udf)
+            self.assertEquals(info, udf_dict)
+            self.main.vm.udf_deleted(udf.volume_id)
+
+        d.addCallback(check)
+        d.addErrback(self.error_handler)
+        return d
+
+    def test_create_server_error(self):
+        """Test for Folders.create."""
+        path = os.path.join(self.home_dir, u'ñoño')
+        d = defer.Deferred()
+        # patch AQ.create_udf
+        def create_udf(path, name, marker):
+            """Fake create_udf, that fails."""
+            self.main.event_q.push("AQ_CREATE_UDF_ERROR",
+                                   marker=marker, error="Oops, error!")
+        self.main.action_q.create_udf = create_udf
+        def create_handler(info, error):
+            """FolderCreateError handler."""
+            d.callback((info, error))
+        match = self.bus.add_signal_receiver(create_handler,
+                                             signal_name='FolderCreateError')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('create', path,
+                                        reply_handler=lambda *agrs: None,
+                                        error_handler=self.error_handler)
+        def check(result):
+            """Check the result."""
+            info, error = result
+            self.assertEquals(info['path'], path)
+            self.assertEquals(error, 'Oops, error!')
+        d.addCallback(check)
+        return d
+
+    def test_create_client_error(self):
+        """Test for Folders.create."""
+        path = os.path.join(self.home_dir, u'ñoño')
+        d = defer.Deferred()
+        # patch AQ.create_udf
+        def create_udf(path, name, marker):
+            """Fake create_udf, that fails."""
+            raise ValueError("I'm broken.")
+        self.main.action_q.create_udf = create_udf
+        def create_handler(info, error):
+            """FolderCreateError handler."""
+            d.callback((info, error))
+        match = self.bus.add_signal_receiver(create_handler,
+                                             signal_name='FolderCreateError')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('create', path,
+                                        reply_handler=lambda *agrs: None,
+                                        error_handler=self.error_handler)
+        def check(result):
+            """Check the result."""
+            info, error = result
+            self.assertEquals(info['path'], path)
+            self.assertEquals(error, "UNKNOWN_ERROR: I'm broken.")
+        d.addCallback(check)
+        return d
+
+    def test_create_error_signal(self):
+        """Test for FolderCreateError."""
+        path = os.path.join(self.home_dir, u'ñoño'.encode('utf-8'))
+        d = defer.Deferred()
+        def create_error_handler(info, error):
+            """FolderCreateError handler"""
+            self.assertEquals(info['path'], path.decode('utf-8'))
+            self.assertEquals(error, "I'm broken")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(create_error_handler,
+                                             signal_name='FolderCreateError')
+        self.signal_receivers.add(match)
+        # TODO: once create_udf is implemented remove this callLater
+        reactor.callLater(0, self.main.event_q.push,
+                          'VM_UDF_CREATE_ERROR', path=path, error="I'm broken")
+        return d
+
+    @defer.inlineCallbacks
+    def test_delete(self):
+        """Test for Folders.delete."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        def delete_volume(volume_id, path):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=udf.id)
+        self.main.action_q.delete_volume = delete_volume
+        def deleted_handler(info):
+            """FolderDeleted handler."""
+            self.assertRaises(KeyError, self.main.fs.get_by_path,
+                              info['path'].encode('utf-8'))
+            self.assertRaises(VolumeDoesNotExist,
+                              self.main.vm.get_volume, str(info['volume_id']))
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_handler,
+                                             signal_name='FolderDeleted')
+        self.signal_receivers.add(match)
+        def check_deleted(info):
+            """The callback."""
+            self.assertNotIn(udf.volume_id, self.main.vm.udfs)
+            self.assertRaises(KeyError, self.main.fs.get_by_path, udf.path)
+            self.assertRaises(VolumeDoesNotExist,
+                              self.main.vm.get_volume, udf.volume_id)
+        self.folders_client.call_method('delete', udf.volume_id,
+                                        reply_handler=check_deleted,
+                                        error_handler=self.error_handler)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_delete_error_signal(self):
+        """Test for FolderDeleteError."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        # patch delete_volume to fail
+        def delete_volume(volume_id, path):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_VOLUME_ERROR",
+                                   volume_id=udf.volume_id, error="I'm broken")
+        self.main.action_q.delete_volume = delete_volume
+        def deleted_error_handler(info, error):
+            """FolderDeleteError handler."""
+            self.assertEquals(info['volume_id'], udf.volume_id)
+            self.assertEquals(error, "I'm broken")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='FolderDeleteError')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('delete', udf.volume_id,
+                                        reply_handler=lambda *args: None,
+                                        error_handler=self.error_handler)
+        yield d
+        self.main.vm.udf_deleted(udf.volume_id)
+
+    @defer.inlineCallbacks
+    def test_delete_error_signal_folder_id(self):
+        """Test for FolderDeleteError for a volume that doesn't exists."""
+        udf_id = 'foobar'
+        d = defer.Deferred()
+        def deleted_error_handler(info, error):
+            """FolderDeleteError handler."""
+            d.callback((info, error))
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='FolderDeleteError')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('delete', udf_id,
+                                        reply_handler=lambda *args: None,
+                                        error_handler=d.errback)
+        info, error = yield d
+        self.assertEquals(info['volume_id'], udf_id)
+        self.assertEquals(error, "DOES_NOT_EXIST")
+
+    @defer.inlineCallbacks
+    def test_subscribe(self):
+        """Test for Folders.subscribe and that it fires a dbus signal."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=False)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        def subscribe_handler(info):
+            """FolderSubscribed handler."""
+            d.callback(info)
+        match = self.bus.add_signal_receiver(subscribe_handler,
+                                             signal_name='FolderSubscribed')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('subscribe', udf.volume_id,
+                                        reply_handler=lambda x: None,
+                                        error_handler=self.error_handler)
+        def check(info):
+            """Check that the folder is subscribed."""
+            self.assertTrue(info['subscribed'],
+                            "UDF %s isn't subscribed" % udf.volume_id)
+        d.addCallback(check)
+        d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_unsubscribe(self):
+        """Test for Folders.unsubscribe."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=True)
+        yield self.main.vm.add_udf(udf)
+        d = defer.Deferred()
+        self.folders_client.call_method('unsubscribe', udf.volume_id,
+                                        reply_handler=d.callback,
+                                        error_handler=self.error_handler)
+        def check(r):
+            """Check that the folder it's not subscribed."""
+            self.assertFalse(self.main.vm.udfs[udf.volume_id].subscribed,
+                            "UDF %s is subscribed" % udf.volume_id)
+        d.addCallback(check)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_unsubscribe_signal(self):
+        """Test for Folders.unsubscribe fired dbus signal."""
+        suggested_path = u'~/ñoño'
+        udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path,
+                               subscribed=True)
+        yield self.main.vm.add_udf(udf)
+        signal_deferred = defer.Deferred()
+        d = defer.Deferred()
+        def unsubscribe_handler(info):
+            """FolderUnSubscribed handler."""
+            self.assertFalse(info['subscribed'],
+                             "UDF %s is subscribed" % udf.volume_id)
+            signal_deferred.callback(info)
+        match = self.bus.add_signal_receiver(unsubscribe_handler,
+                                             signal_name='FolderUnSubscribed')
+        self.signal_receivers.add(match)
+        self.folders_client.call_method('unsubscribe', udf.volume_id,
+                                        reply_handler=d.callback,
+                                        error_handler=self.error_handler)
+        def check(r):
+            """Check that the folder it's not subscribed."""
+            a_udf = self.main.vm.udfs[udf.volume_id]
+            self.assertFalse(a_udf.subscribed,
+                            "UDF %s is subscribed" % a_udf.volume_id)
+            return signal_deferred
+        d.addCallback(check)
+        d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
+        yield d
+
+    @defer.inlineCallbacks
+    def test_refresh_volumes(self):
+        """Just check that refresh_volumes method works."""
+        client = DBusClient(self.bus, '/folders', DBUS_IFACE_FOLDERS_NAME)
+        list_volumes_d = defer.Deferred()
+        self.main.action_q.list_volumes = lambda: list_volumes_d.callback(True)
+
+        d = defer.Deferred()
+        client.call_method('refresh_volumes',
+                           reply_handler=d.callback,
+                           error_handler=self.error_handler)
+        yield list_volumes_d
+        yield d
+
+
+class LauncherTests(DBusTwistedTestCase, MockerTestCase):
+    """Tests for the launcher Dbus Interface."""
+
+    @defer.inlineCallbacks
+    def test_unset_urgency(self):
+        """Calling remove_urgency removes the urgency hint."""
+        launcher = self.mocker.replace(
+            "ubuntuone.platform.linux.launcher.UbuntuOneLauncher")
+        launcher()
+        launcher_instance = self.mocker.mock()
+        self.mocker.result(launcher_instance)
+        launcher_instance.set_urgent(False)
+        self.mocker.replay()
+        client = DBusClient(self.bus, '/launcher', DBUS_IFACE_LAUNCHER_NAME)
+        d = defer.Deferred()
+        client.call_method('unset_urgency',
+                           reply_handler=d.callback,
+                           error_handler=self.error_handler)
+        yield d
+
+
+class ShareTests(DBusTwistedTestCase):
+    """Share specific tests."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup the test."""
+        yield super(ShareTests, self).setUp()
+        self.client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
+
+    def _create_share(self, volume_id=None, node_id=None, access_level='View',
+                      accepted=True, subscribed=False):
+        """Create a Share and return it."""
+        share_path = os.path.join(self.main.shares_dir, 'share')
+        if volume_id is None:
+            volume_id = str(uuid.uuid4())
+        if node_id is None:
+            node_id = str(uuid.uuid4())
+        share = Share(path=share_path, volume_id=volume_id, node_id=node_id,
+                      accepted=accepted, access_level=access_level,
+                      subscribed=subscribed)
+        return share
+
+    @defer.inlineCallbacks
+    def test_delete_share(self):
+        """Test for Shares.delete_share."""
+        share = self._create_share(accepted=True)
+        yield self.main.vm.add_share(share)
+        d = defer.Deferred()
+        def delete_volume(volume_id, path):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=volume_id)
+        self.main.action_q.delete_volume = delete_volume
+        def deleted_handler(info):
+            """ShareDeleted handler."""
+            self.assertRaises(KeyError, self.main.fs.get_by_path,
+                              info['path'].decode('utf-8'))
+            self.assertRaises(VolumeDoesNotExist,
+                              self.main.vm.get_volume, str(info['volume_id']))
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_handler,
+                                             signal_name='ShareDeleted')
+        self.signal_receivers.add(match)
+        def check_deleted(info):
+            """The callback."""
+            self.assertNotIn(share.volume_id, self.main.vm.shares)
+            self.assertRaises(KeyError, self.main.fs.get_by_path, share.path)
+            self.assertRaises(VolumeDoesNotExist,
+                              self.main.vm.get_volume, share.volume_id)
+        self.client.call_method('delete_share', share.volume_id,
+                           reply_handler=check_deleted,
+                           error_handler=self.error_handler)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_delete_share_from_me(self):
+        """Test for Shares.delete_share with share from_me."""
+        share = self._create_share(accepted=True)
+        yield self.main.vm.add_shared(share)
+        d = defer.Deferred()
+        def delete_share(volume_id):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_SHARE_OK", share_id=volume_id)
+        self.patch(self.main.action_q, 'delete_share', delete_share)
+        def deleted_handler(info):
+            """ShareDeleted handler."""
+            self.assertRaises(KeyError,
+                              self.main.vm.shared.__getitem__, str(info['volume_id']))
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_handler,
+                                             signal_name='ShareDeleted')
+        self.signal_receivers.add(match)
+        self.client.call_method('delete_share', share.volume_id,
+                           reply_handler=lambda _: None,
+                           error_handler=self.error_handler)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_delete_share_error_signal(self):
+        """Test for Shares.delete_share with an error."""
+        share = self._create_share(accepted=True)
+        yield self.main.vm.add_share(share)
+        d = defer.Deferred()
+        # patch delete_volume to fail
+        def delete_volume(volume_id, path):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_VOLUME_ERROR",
+                                   volume_id=volume_id, error="I'm broken")
+        self.main.action_q.delete_volume = delete_volume
+        def deleted_error_handler(info, error):
+            """ShareDeleteError handler."""
+            self.assertEquals(info['volume_id'], share.volume_id)
+            self.assertEquals(error, "I'm broken")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='ShareDeleteError')
+        self.signal_receivers.add(match)
+        self.client.call_method('delete_share', share.volume_id,
+                           reply_handler=lambda *args: None,
+                           error_handler=self.error_handler)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_delete_share_from_me_error(self):
+        """Test failure of Shares.delete_share with a share from_me."""
+        share = self._create_share(accepted=True)
+        yield self.main.vm.add_shared(share)
+        d = defer.Deferred()
+        # patch delete_share to fail
+        def delete_share(share_id):
+            """Fake delete_share."""
+            self.main.event_q.push("AQ_DELETE_SHARE_ERROR",
+                                   share_id=share_id, error="I'm broken")
+        self.patch(self.main.action_q, 'delete_share', delete_share)
+        def deleted_error_handler(info, error):
+            """ShareDeleteError handler."""
+            self.assertEquals(info['volume_id'], share.volume_id)
+            self.assertEquals(error, "I'm broken")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='ShareDeleteError')
+        self.signal_receivers.add(match)
+        self.client.call_method('delete_share', share.volume_id,
+                           reply_handler=lambda *args: None,
+                           error_handler=self.error_handler)
+        yield d
+
+    def test_delete_share_from_me_doesnotexist(self):
+        """Test failure of Shares.delete_share with a share from_me."""
+        d = defer.Deferred()
+        # patch delete_share to fail
+        def deleted_error_handler(info, error):
+            """ShareDeleteError handler."""
+            self.assertEquals(info['volume_id'], 'missing_share_id')
+            self.assertEquals(error, "DOES_NOT_EXIST")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='ShareDeleteError')
+        self.signal_receivers.add(match)
+        self.client.call_method('delete_share', 'missing_share_id',
+                           reply_handler=lambda *args: None,
+                           error_handler=self.error_handler)
+        return d
+
+    @defer.inlineCallbacks
+    def test_subscribe(self):
+        """Test for Shares.subscribe and that it fires a dbus signal."""
+        share = self._create_share(accepted=True, subscribed=False)
+        yield self.main.vm.add_share(share)
+
+        d = defer.Deferred()
+        match = self.bus.add_signal_receiver(d.callback,
+                                             signal_name='ShareSubscribed')
+        self.signal_receivers.add(match)
+
+        match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
+                                             signal_name='ShareSubscribeError')
+        self.signal_receivers.add(match)
+
+        self.client.call_method('subscribe', share.volume_id,
+                                reply_handler=lambda x: None,
+                                error_handler=self.error_handler)
+        info = yield d
+        self.assertTrue(bool(info['subscribed']),
+                        "share %r should be subscribed" % share)
+        yield self.main.vm.share_deleted(share.volume_id)
+
+    @defer.inlineCallbacks
+    def test_subscribe_error(self):
+        """Test for Shares.subscribe when there is an error."""
+        # do not add a share to have an error
+
+        d = defer.Deferred()
+
+        match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
+                                             signal_name='ShareSubscribeError')
+        self.signal_receivers.add(match)
+
+        match = self.bus.add_signal_receiver(d.errback,
+                                             signal_name='ShareSubscribed')
+        self.signal_receivers.add(match)
+
+        self.client.call_method('subscribe', 'invalid_id',
+                                reply_handler=lambda x: None,
+                                error_handler=self.error_handler)
+        yield d
+
+    @defer.inlineCallbacks
+    def test_unsubscribe(self):
+        """Test for Shares.unsubscribe."""
+        share = self._create_share(accepted=True, subscribed=True)
+        yield self.main.vm.add_share(share)
+
+        d = defer.Deferred()
+        match = self.bus.add_signal_receiver(d.callback,
+                                             signal_name='ShareUnSubscribed')
+        self.signal_receivers.add(match)
+
+        match = self.bus.add_signal_receiver(lambda _, error: d.errback(error),
+                                           signal_name='ShareUnSubscribeError')
+        self.signal_receivers.add(match)
+
+        self.client.call_method('unsubscribe', share.volume_id,
+                                reply_handler=lambda x: None,
+                                error_handler=self.error_handler)
+        info = yield d
+
+        self.assertFalse(info['subscribed'],
+                         "share %r should be subscribed" % share)
+
+        self.main.vm.share_deleted(share.volume_id)
+
+    @defer.inlineCallbacks
+    def test_unsubscribe_error(self):
+        """Test for Shares.unsubscribe when there is an error."""
+        # do not add a share to have an error
+
+        d = defer.Deferred()
+        match = self.bus.add_signal_receiver(lambda sid, _: d.callback(sid),
+                                           signal_name='ShareUnSubscribeError')
+        self.signal_receivers.add(match)
+
+        match = self.bus.add_signal_receiver(d.errback,
+                                             signal_name='ShareUnSubscribed')
+        self.signal_receivers.add(match)
+
+        self.client.call_method('unsubscribe', 'invalid_id',
+                                reply_handler=lambda x: None,
+                                error_handler=self.error_handler)
+        yield d
+
+
+class TestStatusEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestStatusEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+
+    def test_emit_content_queue_changed(self):
+        """Emit ContentQueueChanged."""
+        self.status.ContentQueueChanged = self.signal_method
+        self.signal_method()
+        self.mocker.replay()
+        # will assert that the signal method was called
+        self.status.emit_content_queue_changed()
+
+    def test_emit_requestqueue_removed(self):
+        """Emit RequestQueueRemoved."""
+        self.status.RequestQueueRemoved = self.signal_method
+        self.signal_method('name', 'id', {})
+        self.mocker.replay()
+        # will assert that the signal method was called
+        self.status.emit_requestqueue_removed('name', 'id', {})
+
+    def test_emit_requestqueue_added(self):
+        """Emit RequestQueueAdded."""
+        self.status.RequestQueueAdded = self.signal_method
+        self.signal_method('name', 'id', {})
+        self.mocker.replay()
+        # will assert that the signal method was called
+        self.status.emit_requestqueue_added('name', 'id', {})
+
+    def test_emit_invalid_name(self):
+        """Emit InvalidName."""
+        dirname = 'dirname'
+        filename = 'filename'
+        self.status.InvalidName = self.signal_method
+        self.signal_method(unicode(dirname), str(filename))
+        self.mocker.replay()
+        self.status.emit_invalid_name(dirname, filename)
+
+    def test_emit_broken_node(self):
+        """Emit BrokenNode."""
+        volume_id = 'volume_id'
+        node_id = 'node_id'
+        mdid = 'mdid'
+        path = 'path'
+        self.status.BrokenNode = self.signal_method
+        self.signal_method(volume_id, node_id, mdid, path.decode('utf8'))
+        self.mocker.replay()
+        self.status.emit_broken_node(volume_id, node_id, mdid,
+                                     path.decode('utf8'))
+
+    def test_emit_status_changed(self):
+        """Emit StatusChanged."""
+        status = 'status'
+        status_mock = self.mocker.mock()
+        self.status.syncdaemon_status = status_mock
+        status_mock.current_status()
+        self.mocker.result(status)
+        self.status.StatusChanged = self.signal_method
+        self.signal_method(status)
+        self.mocker.replay()
+        self.status.emit_status_changed(status)
+
+    def test_emit_download_started(self):
+        """Emit DownloadStarted."""
+        download = 'download'
+        self.status.DownloadStarted = self.signal_method
+        self.signal_method(download)
+        self.mocker.replay()
+        self.status.emit_download_started(download)
+
+    def test_emit_download_file_progress(self):
+        """Emit DownloadFileProgress."""
+        download = 'download'
+        string_info = {'blah':'3', 'do':'4'}
+        self.status.DownloadFileProgress = self.signal_method
+        self.signal_method(download, string_info)
+        self.mocker.replay()
+        self.status.emit_download_file_progress(download, blah=3, do=4)
+
+    def test_emit_download_finished(self):
+        """Emit DownloadFinished."""
+        download = 'download'
+        string_info = {'blah':'3', 'do':'4'}
+        self.status.DownloadFinished = self.signal_method
+        self.signal_method(download, string_info)
+        self.mocker.replay()
+        self.status.emit_download_finished(download, blah=3, do=4)
+
+    def test_emit_upload_started(self):
+        """Emit UploadStarted."""
+        upload = 'upload'
+        self.status.UploadStarted = self.signal_method
+        self.signal_method(upload)
+        self.mocker.replay()
+        self.status.emit_upload_started(upload)
+
+    def test_emit_upload_file_progress(self):
+        """Emit UploadFileProgress."""
+        upload = 'upload'
+        string_info = {'blah':'3', 'do':'4'}
+        self.status.UploadFileProgress = self.signal_method
+        self.signal_method(upload , string_info)
+        self.mocker.replay()
+        self.status.emit_upload_file_progress(upload , blah=3, do=4)
+
+    def test_emit_upload_finished(self):
+        """Emit UploadFinished."""
+        upload = 'upload'
+        string_info = {'blah':'3', 'do':'4'}
+        self.status.UploadFinished= self.signal_method
+        self.signal_method(upload , string_info)
+        self.mocker.replay()
+        self.status.emit_upload_finished(upload, blah=3, do=4)
+
+    def test_emit_account_changed(self):
+        """Emit AccountChanged."""
+        info_dict = {'purchased_bytes': unicode('34')}
+        account_info = self.mocker.mock()
+        account_info.purchased_bytes
+        self.mocker.result('34')
+        self.status.AccountChanged = self.signal_method
+        self.signal_method(info_dict)
+        self.mocker.replay()
+        self.status.emit_account_changed(account_info)
+
+    def test_emit_metaqueue_changed(self):
+        """Emit MetaQueueChanged."""
+        self.status.MetaQueueChanged = self.signal_method
+        self.signal_method()
+        self.mocker.replay()
+        self.status.emit_metaqueue_changed()
+
+
+class TestEventsEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestEventsEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+
+    def test_emit_event(self):
+        """Test the Event signal."""
+        items = {1:2}
+        event = self.mocker.mock()
+        event.iteritems()
+        self.mocker.result(items.iteritems())
+        self.events.Event = self.signal_method
+        self.signal_method({'1':'2'})
+        self.mocker.replay()
+        self.events.emit_event(event)
+
+
+class TestSyncDaemonEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestSyncDaemonEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+
+
+    def test_emit_root_mismatch(self):
+        """Emit RootMismatch signal."""
+        root_id = 'root_id'
+        new_root_id = 'new_root_id'
+        self.sync.RootMismatch = self.signal_method
+        self.signal_method(root_id, new_root_id)
+        self.mocker.replay()
+        self.sync.emit_root_mismatch(root_id, new_root_id)
+
+    def test_emit_quota_exceeded(self):
+        """Emit QuotaExceeded signal."""
+        volume_dict = 'volume_dict'
+        self.sync.QuotaExceeded = self.signal_method
+        self.signal_method(volume_dict)
+        self.mocker.replay()
+        self.sync.emit_quota_exceeded(volume_dict)
+
+
+class TestSharesEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestSharesEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+        self.shares.syncdaemon_shares = self.mocker.mock()
+        self.get_share_dict = self.mocker.replace(
+            'ubuntuone.syncdaemon.interaction_interfaces.get_share_dict')
+
+    def test_emit_share_changed_deleted(self):
+        share = 'share'
+        message = 'deleted'
+        share_dict = {'share':'id'}
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareDeleted = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_share_changed(message, share)
+
+    def test_emit_share_changed_changed(self):
+        share = 'share'
+        message = 'changed'
+        share_dict = {'share':'id'}
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareChanged = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_share_changed(message, share)
+
+    def test_emit_share_delete_error(self):
+        """Emit ShareDeleteError signal."""
+        share = 'share'
+        error = 'error'
+        share_dict = {'share':'id'}
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareDeleteError = self.signal_method
+        self.signal_method(share_dict, error)
+        self.mocker.replay()
+        self.shares.emit_share_delete_error(share, error)
+
+    def test_emit_free_space(self):
+        """Emit ShareChanged when free space changes """
+        free_bytes = '0'
+        share_dict = shares = {'1': 'share', 'free_bytes':'0' }
+        share = 'share'
+        share_id = '1'
+        self.shares.syncdaemon_shares.shares
+        self.mocker.result(shares)
+        self.shares.syncdaemon_shares.shares
+        self.mocker.result(shares)
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareChanged = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_free_space(share_id, free_bytes)
+
+    def test_emit_share_created(self):
+        """Emit ShareCreated signal """
+        share_info = 'info'
+        self.shares.ShareCreated = self.signal_method
+        self.signal_method(share_info)
+        self.mocker.replay()
+        self.shares.emit_share_created(share_info)
+
+    def test_emit_share_create_error(self):
+        """Emit ShareCreateError signal."""
+        share_info = 'id'
+        error = 'error'
+        info = 'info'
+        self.shares.syncdaemon_shares.get_create_error_share_info(share_info)
+        self.mocker.result(info)
+        self.shares.ShareCreateError = self.signal_method
+        self.signal_method(info, error)
+        self.mocker.replay()
+        self.shares.emit_share_create_error(share_info, error)
+
+    def test_emit_share_answer_response(self):
+        """Emits ShareAnswerResponse signal."""
+        share_id = 'id'
+        answer = 'yes'
+        error = 'boom'
+        answer_info = dict(volume_id=share_id, answer=answer, error=error)
+        self.shares.ShareAnswerResponse = self.signal_method
+        self.signal_method(answer_info)
+        self.mocker.replay()
+        self.shares.emit_share_answer_response(share_id, answer, error)
+
+    def test_emit_new_share(self):
+        """Emits NewShare signal."""
+        share_id = 'id'
+        share = 'share'
+        share_dict = {'share':'id'}
+        self.shares.syncdaemon_shares.get_volume(share_id)
+        self.mocker.result(share)
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.NewShare = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_new_share(share_id)
+
+    def test_emit_share_subscribed(self):
+        """Emit the ShareSubscribed signal"""
+        share = 'share'
+        share_dict = {'share' : 'id'}
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareSubscribed = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_share_subscribed(share)
+
+    def test_emit_share_subscribe_error(self):
+        """Emit the ShareSubscribeError signal"""
+        share_id = 'id'
+        error = 'error'
+        self.shares.ShareSubscribeError = self.signal_method
+        self.signal_method({'id': share_id}, str(error))
+        self.mocker.replay()
+        self.shares.emit_share_subscribe_error(share_id, error)
+
+    def test_emit_share_unsubscribed(self):
+        """Emit the ShareUnSubscribed signal"""
+        share = 'share'
+        share_dict = {'share':'id'}
+        self.get_share_dict(share)
+        self.mocker.result(share_dict)
+        self.shares.ShareUnSubscribed = self.signal_method
+        self.signal_method(share_dict)
+        self.mocker.replay()
+        self.shares.emit_share_unsubscribed(share)
+
+    def test_emit_share_unsubscribe_error(self):
+        """Emit the ShareUnSubscribeError signal"""
+        share_id = 'id'
+        error = 'error'
+        self.shares.ShareUnSubscribeError = self.signal_method
+        self.signal_method({'id': share_id}, str(error))
+        self.mocker.replay()
+        self.shares.emit_share_unsubscribe_error(share_id, error)
+
+
+class TestFoldersEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestFoldersEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+        self.get_udf_dict = self.mocker.replace(
+            'ubuntuone.syncdaemon.interaction_interfaces.get_udf_dict')
+
+    def test_emit_folder_deleted(self):
+        """Emit the FolderCreated signal"""
+        folder = 'folder'
+        udf_dict = {'udf':'id'}
+        self.get_udf_dict(folder)
+        self.mocker.result(udf_dict)
+        self.folders.FolderDeleted = self.signal_method
+        self.signal_method(udf_dict)
+        self.mocker.replay()
+        self.folders.emit_folder_deleted(folder)
+
+    def test_emit_folder_delete_error(self):
+        """Emit the FolderCreateError signal"""
+        folder = 'folder'
+        error = 'error'
+        udf_dict = {'udf':'id'}
+        self.get_udf_dict(folder)
+        self.mocker.result(udf_dict)
+        self.folders.FolderDeleteError = self.signal_method
+        self.signal_method(udf_dict, str(error))
+        self.mocker.replay()
+        self.folders.emit_folder_delete_error(folder, error)
+
+    def test_emit_folder_subscribed(self):
+        """Emit the FolderSubscribed signal"""
+        folder = 'folder'
+        udf_dict = {'udf':'id'}
+        self.get_udf_dict(folder)
+        self.mocker.result(udf_dict)
+        self.folders.FolderSubscribed = self.signal_method
+        self.signal_method(udf_dict)
+        self.mocker.replay()
+        self.folders.emit_folder_subscribed(folder)
+
+    def test_emit_folder_subscribe_error(self):
+        """Emit the FolderSubscribeError signal"""
+        folder_id = 'id'
+        error = 'error'
+        self.folders.FolderSubscribeError = self.signal_method
+        self.signal_method({'id':folder_id}, str(error))
+        self.mocker.replay()
+        self.folders.emit_folder_subscribe_error(folder_id, error)
+
+    def test_emit_folder_unsubscribed(self):
+        """Emit the FolderUnSubscribed signal"""
+        folder = 'folder'
+        udf_dict = {'udf':'id'}
+        self.get_udf_dict(folder)
+        self.mocker.result(udf_dict)
+        self.folders.FolderUnSubscribed = self.signal_method
+        self.signal_method(udf_dict)
+        self.mocker.replay()
+        self.folders.emit_folder_unsubscribed(folder)
+
+    def test_emit_folder_unsubscribe_error(self):
+        """Emit the FolderUnSubscribeError signal"""
+        folder_id = 'id'
+        error = 'error'
+        self.folders.FolderUnSubscribeError= self.signal_method
+        self.signal_method({'id':folder_id}, str(error))
+        self.mocker.replay()
+        self.folders.emit_folder_unsubscribe_error(folder_id, error)
+
+
+class TestPublicFilesEmitSignals(DBusTwistedTestCase, MockerTestCase):
+    """Test that the emit method have been correctly implemented."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup tests."""
+        yield super(TestPublicFilesEmitSignals, self).setUp()
+        self.signal_method = self.mocker.mock()
+        self.public_files.syncdaemon_public_files = self.mocker.mock()
+        self.bool_str = self.mocker.replace(
+            'ubuntuone.syncdaemon.interaction_interfaces.bool_str')
+
+    def test_emit_public_access_changed(self):
+        """Emit the PublicAccessChanged signal."""
+        share_id = 'share_id'
+        node_id = 'node_id'
+        path = 'path'
+        is_public = True
+        public_url = 'url'
+        self.public_files.syncdaemon_public_files.get_path(share_id, node_id)
+        self.mocker.result(path)
+        self.bool_str(is_public)
+        self.mocker.result('True')
+        self.public_files.PublicAccessChanged = self.signal_method
+        self.signal_method(dict(share_id=share_id, node_id=node_id,
+                                is_public='True', public_url=public_url,
+                                path=path))
+        self.mocker.replay()
+        self.public_files.emit_public_access_changed(share_id, node_id,
+                                                     is_public, public_url)
+
+    def test_emit_public_access_change_error(self):
+        """Emit the PublicAccessChangeError signal."""
+        share_id = 'share_id'
+        node_id = 'node_id'
+        error = 'error'
+        path = 'path'
+        self.public_files.syncdaemon_public_files.get_path(share_id, node_id)
+        self.mocker.result(path)
+        self.public_files.PublicAccessChangeError = self.signal_method
+        self.signal_method(dict(share_id=share_id, node_id=node_id, path=path),
+                           error)
+        self.mocker.replay()
+        self.public_files.emit_public_access_change_error(share_id, node_id, error)
+
+    def test_emit_public_files_list(self):
+        """Emit the PublicFilesList signal."""
+        volume_id = 'volume_id'
+        node_id = 'node_id'
+        public_url = 'url'
+        path = 'path'
+        public_files = [dict(volume_id=volume_id, node_id=node_id,
+                             public_url=public_url)]
+        files = [dict(volume_id=volume_id, node_id=node_id,
+                      public_url=public_url, path=path)]
+        self.public_files.syncdaemon_public_files.get_path(volume_id, node_id)
+        self.mocker.result(path)
+        self.public_files.PublicFilesList = self.signal_method
+        self.signal_method(files)
+        self.mocker.replay()
+        self.public_files.emit_public_files_list(public_files)
+
+    def test_emit_public_files_list_error(self):
+        """Emit the PublicFilesListError signal."""
+        error = 'error'
+        self.public_files.PublicFilesListError = self.signal_method
+        self.signal_method(error)
+        self.mocker.replay()
+        self.public_files.emit_public_files_list_error(error)
+>>>>>>> MERGE-SOURCE

=== modified file 'tests/platform/linux/test_messaging.py'
--- tests/platform/linux/test_messaging.py	2011-10-27 11:39:43 +0000
+++ tests/platform/linux/test_messaging.py	2011-12-14 21:48:23 +0000
@@ -22,9 +22,13 @@
 """
 
 
+<<<<<<< TREE
 from mocker import Mocker, ANY
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
+=======
+from mocker import ANY, MockerTestCase as TestCase
+>>>>>>> MERGE-SOURCE
 
 from ubuntuone.platform.linux.messaging import Messaging, _server_callback
 
@@ -43,6 +47,7 @@
 class MessagingTestCase(TestCase):
     """Test the Messaging API."""
 
+<<<<<<< TREE
     @defer.inlineCallbacks
     def setUp(self):
         yield super(MessagingTestCase, self).setUp()
@@ -54,6 +59,8 @@
         self.mocker.restore()
         self.mocker.verify()
 
+=======
+>>>>>>> MERGE-SOURCE
     # pylint: disable=R0913
     def _show_message_setup(self, message_time=None, message_count=None,
                             icon=None, update_count=None, real_callback=False):

=== modified file 'tests/platform/linux/test_notification.py'
--- tests/platform/linux/test_notification.py	2011-10-27 11:39:43 +0000
+++ tests/platform/linux/test_notification.py	2011-12-14 21:48:23 +0000
@@ -22,9 +22,13 @@
 """
 
 
+<<<<<<< TREE
 from mocker import Mocker
 from twisted.internet import defer
 from twisted.trial.unittest import TestCase
+=======
+from mocker import MockerTestCase as TestCase
+>>>>>>> MERGE-SOURCE
 
 from ubuntuone.platform.linux.notification import Notification, ICON_NAME
 
@@ -46,6 +50,7 @@
 class NotificationTestCase(TestCase):
     """Test the Messaging API."""
 
+<<<<<<< TREE
     @defer.inlineCallbacks
     def setUp(self):
         yield super(NotificationTestCase, self).setUp()
@@ -57,6 +62,8 @@
         self.mocker.restore()
         self.mocker.verify()
 
+=======
+>>>>>>> MERGE-SOURCE
     def test_send_notification(self):
         """On notification, pynotify receives the proper calls."""
         mock_notify = self.mocker.replace("pynotify")

=== modified file 'tests/platform/linux/test_vm.py'
--- tests/platform/linux/test_vm.py	2011-11-17 19:19:08 +0000
+++ tests/platform/linux/test_vm.py	2011-12-14 21:48:23 +0000
@@ -19,9 +19,15 @@
 import os
 import uuid
 
+<<<<<<< TREE
 from twisted.internet import defer
 
 from contrib.testing.testcase import FakeMain
+=======
+from twisted.internet import defer
+
+from contrib.testing.testcase import FakeMain, environ
+>>>>>>> MERGE-SOURCE
 from tests.syncdaemon.test_vm import MetadataTestCase, BaseVolumeManagerTests
 from ubuntuone.storageprotocol import request
 from ubuntuone.syncdaemon.volume_manager import (

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2011-12-07 20:41:48 +0000
+++ tests/status/test_aggregator.py	2011-12-14 21:48:23 +0000
@@ -249,8 +249,13 @@
     @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+<<<<<<< TREE
         yield super(ToggleableNotificationTestCase, self).setUp()
         self.patch(aggregator.notification, "Notification", FakeNotification)
+=======
+        yield super(ToggleableNotificationTestCase, self).setUp()
+        self.patch(aggregator, "Notification", FakeNotification)
+>>>>>>> MERGE-SOURCE
         self.notification_switch = aggregator.NotificationSwitch()
         self.toggleable = self.notification_switch.get_notification()
 

=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2011-11-08 15:29:55 +0000
+++ tests/syncdaemon/test_action_queue.py	2011-12-14 21:48:23 +0000
@@ -120,7 +120,43 @@
         self.closed = 0  # be able to count how may close calls we had
         self.name = os.path.join(tmpdir, 'remove-me.zip')
         open_file(self.name, 'w').close()
-        self.close = lambda: setattr(self, 'closed', self.closed + 1)
+<<<<<<< TREE
+        self.close = lambda: setattr(self, 'closed', self.closed + 1)
+=======
+        self.close = lambda: setattr(self, 'closed', self.closed + 1)
+
+
+class FakeCommand(object):
+    """Yet another fake action queue command."""
+
+    is_runnable = True
+    paused = False
+    conditions_checked = False
+
+    def __init__(self, share_id=None, node_id=None):
+        self.share_id = share_id
+        self.node_id = node_id
+        self.cancelled = False
+        self.log = logging.getLogger('ubuntuone.SyncDaemon')
+
+    run = lambda self: defer.succeed(True)
+
+    def pause(self):
+        """Mark as paused."""
+        self.paused = True
+
+    @property
+    def uniqueness(self):
+        """Fake uniqueness."""
+        if self.share_id is None and self.node_id is None:
+            return self
+        else:
+            return (self.__class__.__name__, self.share_id, self.node_id)
+
+    def cancel(self):
+        """Cancel!"""
+        self.cancelled = True
+>>>>>>> MERGE-SOURCE
 
 
 class FakedEventQueue(EventQueue):
@@ -3724,6 +3760,7 @@
         self.assertEqual('share_name', name)
         self.assertTrue(read_only)
 
+<<<<<<< TREE
     @defer.inlineCallbacks
     def test_create_share_http_uses_timestamp(self):
         """The timestamp is used for oauth signing."""
@@ -3745,6 +3782,29 @@
         self.assertTrue(command.use_http, 'CreateShare should be in http mode')
         yield command._run()
 
+=======
+    @defer.inlineCallbacks
+    def test_create_share_http_uses_timestamp(self):
+        """The timestamp is used for oauth signing."""
+        fake_timestamp = 12345678
+
+        def fake_urlopen(request):
+            """A fake urlopen."""
+            auth = request.headers["Authorization"]
+            expected = 'oauth_timestamp="%d"' % fake_timestamp
+            self.assertIn(expected, auth)
+
+        self.patch(action_queue.timestamp_checker, "get_faithful_time",
+                   lambda: fake_timestamp)
+        self.patch(action_queue, "urlopen", fake_urlopen)
+        self.user_connect()
+        command = CreateShare(self.request_queue, 'node_id',
+                                   '[e-mail]', 'share_name',
+                                   'View', 'marker', 'path')
+        self.assertTrue(command.use_http, 'CreateShare should be in http mode')
+        yield command._run()
+
+>>>>>>> MERGE-SOURCE
     def test_possible_markers(self):
         """Test that it returns the correct values."""
         cmd = CreateShare(self.request_queue, 'node_id', '[e-mail]',

=== modified file 'tests/syncdaemon/test_fsm.py'
=== modified file 'tests/syncdaemon/test_interaction_interfaces.py'
--- tests/syncdaemon/test_interaction_interfaces.py	2011-12-12 19:32:25 +0000
+++ tests/syncdaemon/test_interaction_interfaces.py	2011-12-14 21:48:23 +0000
@@ -13,6 +13,7 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
+<<<<<<< TREE
 
 """Test the interaction_interfaces module."""
 
@@ -124,7 +125,22 @@
     kwargs = {}
 
     @defer.inlineCallbacks
+=======
+"""Test that the interaction_interfaces are correctly called."""
+
+from mocker import MockerTestCase, MATCH
+from twisted.internet import defer
+
+from tests.platform import IPCTestCase
+
+
+class TestStatusIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+>>>>>>> MERGE-SOURCE
     def setUp(self):
+<<<<<<< TREE
         self.patch(interaction_interfaces, 'ExternalInterface',
                    FakedExternalInterface)
         yield super(BaseTestCase, self).setUp()
@@ -185,6 +201,12 @@
     """Test the SyncdaemonStatus class."""
 
     sd_class = SyncdaemonStatus
+=======
+        """Set up tests."""
+        yield super(TestStatusIPC, self).setUp()
+        self.syncdaemon_status = self.mocker.mock()
+        self.status.syncdaemon_status = self.syncdaemon_status
+>>>>>>> MERGE-SOURCE
 
     def test_current_status(self):
         """Test the current_status method."""
@@ -369,6 +391,7 @@
         self.assertTrue(self.handler.check_warning('deprecated'))
 
     def test_waiting_content(self):
+<<<<<<< TREE
         """Test the waiting_content method."""
         self.action_q.queue.waiting.extend([
             FakeUpload("share_id", "node_id_b"),
@@ -397,6 +420,128 @@
     sd_class = SyncdaemonFileSystem
 
     @defer.inlineCallbacks
+=======
+        """Test if the method is relayed."""
+        result = []
+        self.syncdaemon_status.waiting_content()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.status.waiting_content())
+
+    def test_current_uploads(self):
+        """Test if the method is relayed."""
+        result = 'uploading'
+        self.syncdaemon_status.current_uploads()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.status.current_uploads())
+
+
+class TestEventsIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestEventsIPC, self).setUp()
+        self.events_mock = self.mocker.mock()
+        self.events.events = self.events_mock
+
+    def test_push_event(self):
+        """Test if the method is relayed."""
+        event_name = 'name'
+        args = ('uno', 'dos')
+        self.events_mock.push_event(event_name, args)
+        self.mocker.replay()
+        self.events.push_event(event_name, args)
+
+
+class TestSyncDaemonIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestSyncDaemonIPC, self).setUp()
+        self.service = self.mocker.mock()
+        self.sync.service = self.service
+
+    def test_connect(self):
+        """Test if the method is relayed."""
+        self.service.connect()
+        self.mocker.replay()
+        self.sync.connect()
+
+    def test_disconnect(self):
+        """Test if the method is relayed."""
+        self.service.disconnect()
+        self.mocker.replay()
+        self.sync.disconnect()
+
+    def test_get_rootdir(self):
+        """Test if the method is relayed."""
+        result = 'root'
+        self.service.get_rootdir()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.sync.get_rootdir())
+
+    def test_get_sharesdir(self):
+        """Test if the method is relayed."""
+        result = 'shares'
+        self.service.get_sharesdir()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.sync.get_sharesdir())
+
+    def test_get_sharesdir_link(self):
+        """Test if the method is relayed."""
+        result = 'shares'
+        self.service.get_sharesdir_link()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.sync.get_sharesdir_link())
+
+    def test_wait_for_nirvana(self):
+        """Test if the method is relayed."""
+        result = 'nirvana'
+        last_event_interval = 'interval'
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.service.wait_for_nirvana(last_event_interval, MATCH(callable),
+            MATCH(callable))
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.sync.wait_for_nirvana(
+            last_event_interval, reply_handler, error_handler))
+
+    def test_quit(self):
+        """Test if the method is relayed."""
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.service.quit(MATCH(callable), MATCH(callable))
+        self.mocker.replay()
+        self.sync.quit(reply_handler, error_handler)
+
+    def test_rescan_from_scratch(self):
+        """Test if the method is relayed."""
+        volume_id = 'id'
+        self.service.rescan_from_scratch(volume_id)
+        self.mocker.replay()
+        self.sync.rescan_from_scratch(volume_id)
+
+
+class TestFileSystemIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestFileSystemIPC, self).setUp()
+        self.syncdaemon_filesystem = self.mocker.mock()
+        self.fs.syncdaemon_filesystem = self.syncdaemon_filesystem
+
+>>>>>>> MERGE-SOURCE
     def test_get_metadata(self):
         """Test the get_metadata method."""
         share = yield self._create_share()
@@ -569,6 +714,7 @@
         self.assertEqual('synced', result['quick_tree_synced'])
 
     def test_get_dirty_nodes(self):
+<<<<<<< TREE
         """Test the get_dirty_nodes method."""
         # create some nodes
         path1 = os.path.join(self.root_dir, u'ñoño-1'.encode('utf-8'))
@@ -611,6 +757,25 @@
         self.assertEqual(self._called, ((share_id,), {}))
 
     @defer.inlineCallbacks
+=======
+        """Test if the method is relayed."""
+        result = 'dirty'
+        self.syncdaemon_filesystem.get_dirty_nodes()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.fs.get_dirty_nodes())
+
+class TestSharesIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestSharesIPC, self).setUp()
+        self.syncdaemon_shares = self.mocker.mock()
+        self.shares.syncdaemon_shares = self.syncdaemon_shares
+
+>>>>>>> MERGE-SOURCE
     def test_get_shares(self):
         """Test the get_shares method."""
         share = self._create_share(accepted=False)
@@ -753,6 +918,7 @@
         self.assertEqual(self._called, ((), {}))
 
     def test_get_shared(self):
+<<<<<<< TREE
         """Test the get_shared method."""
         a_dir = os.path.join(self.root_dir, "a_dir")
         self.main.fs.create(a_dir, "", is_dir=True)
@@ -877,6 +1043,34 @@
         user_config = config.get_user_config()
         self.assertEqual(user_config.get_throttling_read_limit(), None)
         self.assertEqual(user_config.get_throttling_write_limit(), None)
+=======
+        """Test if the method is relayed."""
+        result = 'shared'
+        self.syncdaemon_shares.get_shared()
+        self.mocker.result(result)
+        self.mocker.replay()
+        self.assertEqual(result, self.shares.get_shared())
+
+
+class TestConfigIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestConfigIPC, self).setUp()
+        self.syncdaemon_config = self.mocker.mock()
+        self.config.syncdaemon_config = self.syncdaemon_config
+
+    def test_get_throttling_limits(self):
+        """Test if the method is relayed."""
+        reply_handler = lambda: None
+        error_handler = lambda: None
+        self.syncdaemon_config.get_throttling_limits(MATCH(callable),
+            MATCH(callable))
+        self.mocker.replay()
+        self.config.get_throttling_limits(reply_handler, error_handler)
+>>>>>>> MERGE-SOURCE
 
     def test_set_throttling_limits(self):
         """Test the set_throttling_limits method."""
@@ -1015,6 +1209,7 @@
         self.assertTrue(config.get_user_config().get_show_all_notifications())
 
     def test_disable_show_all_notifications(self):
+<<<<<<< TREE
         """Test the disable_show_all_notifications method."""
         self.sd_obj.disable_show_all_notifications()
         self.assertFalse(config.get_user_config().get_show_all_notifications())
@@ -1024,6 +1219,23 @@
     """Test the SyncdaemonFolders class."""
 
     sd_class = SyncdaemonFolders
+=======
+        """Test if the method is relayed."""
+        self.syncdaemon_config.disable_show_all_notifications()
+        self.mocker.replay()
+        self.config.disable_show_all_notifications()
+
+
+class TestFoldersIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestFoldersIPC, self).setUp()
+        self.syncdaemon_folders = self.mocker.mock()
+        self.folders.syncdaemon_folders = self.syncdaemon_folders
+>>>>>>> MERGE-SOURCE
 
     def test_create(self):
         """Test the create method."""
@@ -1116,6 +1328,7 @@
         self.assertEqual(info, udf_dict)
 
     def test_refresh_volumes(self):
+<<<<<<< TREE
         """Test the refresh_volumes method."""
         self.patch(self.main.vm, 'refresh_volumes', self._set_called)
         self.sd_obj.refresh_volumes()
@@ -1131,6 +1344,24 @@
     # XXX: change public access is the only class that expects uuid's as
     # params this may indicate that we need to refactor that class to be
     # consistent with the rest of syncdaemon where ID's are always strings
+=======
+        """Test if the method is relayed."""
+        self.syncdaemon_folders.refresh_volumes()
+        self.mocker.replay()
+        self.folders.refresh_volumes()
+
+
+class TestPublicFilesIPC(MockerTestCase, IPCTestCase):
+    """Ensure that calls are correctly fowarded."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set up tests."""
+        yield super(TestPublicFilesIPC, self).setUp()
+        self.syncdaemon_public_files = self.mocker.mock()
+        self.public_files.syncdaemon_public_files =\
+            self.syncdaemon_public_files
+>>>>>>> MERGE-SOURCE
 
     def test_change_public_access(self):
         """Test the change_public_access method."""

=== modified file 'tests/syncdaemon/test_localrescan.py'
=== modified file 'tests/syncdaemon/test_logger.py'
=== modified file 'tests/syncdaemon/test_status_listener.py'
=== modified file 'ubuntuone/status/aggregator.py'
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2011-11-08 15:29:55 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2011-12-14 21:48:23 +0000
@@ -450,11 +450,16 @@
                     break
                 tempfile.write(zipper.compress(data))
                 magic_hasher.update(data)
+<<<<<<< TREE
             # ensure that the contents are phisically in the file, some
             # operating systems will not ensure this, even in the same process
             tempfile.flush()
             upload.deflated_size = tempfile.tell()
 
+=======
+            upload.deflated_size = f.tell()
+
+>>>>>>> MERGE-SOURCE
             upload.magic_hash = magic_hasher.content_hash()
         except Exception, e:  # pylint: disable-msg=W0703
             failed = True
@@ -1769,10 +1774,16 @@
         """Do the actual running."""
         if self.use_http:
             # External user, do the HTTP REST method
+<<<<<<< TREE
             return threads.deferToThread(self._create_share_http,
                                          self.node_id, self.share_to,
                                          self.name,
                                          self.access_level != ACCESS_LEVEL_RW)
+=======
+            return threads.deferToThread(self._create_share_http,
+                                      self.node_id, self.share_to,
+                                      self.name, self.access_level != 'Modify')
+>>>>>>> MERGE-SOURCE
         else:
             return self.action_queue.client.create_share(self.node_id,
                                                          self.share_to,

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'