Merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0

[dobey]

[Diego Sarmentero]

    - Fixing ipc signals in windows and changing deque size to 5.
    - Adding ipc support to share the menu data (LP: #1032659).
    - Collect and return the data for the menu from aggregator (LP: #1032659).
    - Refactoring test for filesystem notifications
    - Use the correct name space (LP: 1026209).

[Rodney Dawes]

    - Move the patching of user_home to before where it is used elsewhere in setUp.

[Alejandro J. Cura]

    - DownloadFinished ipc signal is now thrown after the partial is commited. (LP: #1031197)

[Roberto Alsina]

    - Added check for UDF path not being a file (LP:1033582).

[Roberto Alsina (ralsina)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntuone-client/update-4-0 into lp:ubuntuone-client/stable-4-0 failed. Below is the output from the failed tests.

/usr/bin/gnome-autogen.sh
checking for autoconf >= 2.53...
  testing autoconf2.50... not found.
  testing autoconf... found 2.69
checking for automake >= 1.10...
  testing automake-1.11... found 1.11.5
checking for libtool >= 1.5...
  testing libtoolize... found 2.4.2
checking for intltool >= 0.30...
  testing intltoolize... found 0.50.2
checking for pkg-config >= 0.14.0...
  testing pkg-config... found 0.26
checking for gtk-doc >= 1.0...
  testing gtkdocize... found 1.18
Checking for required M4 macros...
Checking for forbidden M4 macros...
Processing ./configure.ac
Running libtoolize...
libtoolize: putting auxiliary files in `.'.
libtoolize: copying file `./ltmain.sh'
libtoolize: putting macros in AC_CONFIG_MACRO_DIR, `m4'.
libtoolize: copying file `m4/libtool.m4'
libtoolize: copying file `m4/ltoptions.m4'
libtoolize: copying file `m4/ltsugar.m4'
libtoolize: copying file `m4/ltversion.m4'
libtoolize: copying file `m4/lt~obsolete.m4'
Running intltoolize...
Running gtkdocize...
Running aclocal-1.11...
Running autoconf...
Running autoheader...
Running automake-1.11...
Running ./configure --enable-gtk-doc --enable-debug ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking how to create a ustar tar archive... gnutar
checking whether make supports nested variables... yes
checking for style of include used by make... GNU
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for library containing strerror... none required
checking for gcc... (cached) gcc
checking whether we are using the GNU C compiler... (cached) yes
checking whether gcc accepts -g... (cached) yes
checking for gcc option to accept ISO C89... (cached) none needed
checking dependency style of gcc... (cached) gcc3
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking how to print strings... printf
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs......

[lp:~dobey/ubuntuone-client/update-4-0]

1256. By dobey on 2012-08-22

[Diego Sarmentero]

    - Fixing ipc signals in windows and changing deque size to 5.
    - Adding ipc support to share the menu data (LP: #1032659).
    - Collect and return the data for the menu from aggregator (LP: #1032659).
    - Refactoring test for filesystem notifications
    - Use the correct name space (LP: 1026209).

[Rodney Dawes]

    - Move the patching of user_home to before where it is used elsewhere in setUp.

[Alejandro J. Cura]

    - DownloadFinished ipc signal is now thrown after the partial is commited. (LP: #1031197)

[Roberto Alsina]

    - Added check for UDF path not being a file (LP:1033582).

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2012-06-22 09:59:14 +0000
+++ contrib/testing/testcase.py	2012-08-22 18:22:29 +0000
@@ -57,6 +57,8 @@
     main,
     local_rescan,
     tritcask,
+    RECENT_TRANSFERS,
+    UPLOADING,
 )
 from ubuntuone.syncdaemon import logger
 from ubuntuone import platform
@@ -208,6 +210,10 @@
 
     show_all_notifications = True
 
+    def menu_data(self):
+        """Fake menu_data."""
+        return {RECENT_TRANSFERS: [], UPLOADING: []}
+
 
 class FakeMain(main.Main):
     """ A fake Main class to setup the tests """
@@ -385,6 +391,11 @@
     def setUp(self):
         yield super(BaseTwistedTestCase, self).setUp()
         self.__root = None
+
+        # Patch the user home
+        self.home_dir = self.mktemp('ubuntuonehacker')
+        self.patch(platform, "user_home", self.home_dir)
+
         # use the config from the branch
         new_get_config_files = lambda: [os.path.join(os.environ['ROOTDIR'],
                                                    'data', 'syncdaemon.conf')]
@@ -405,9 +416,6 @@
         self.log = logging.getLogger("ubuntuone.SyncDaemon.TEST")
         self.log.info("starting test %s.%s", self.__class__.__name__,
                       self._testMethodName)
-        # Patch the user home
-        self.home_dir = self.mktemp('ubuntuonehacker')
-        self.patch(platform, "user_home", self.home_dir)
         self.patch(action_queue.tunnel_runner, "TunnelRunner",
                    self.tunnel_runner_class)
 

=== modified file 'run-mac-tests'
--- run-mac-tests	2012-07-30 19:31:32 +0000
+++ run-mac-tests	2012-08-22 18:22:29 +0000
@@ -27,7 +27,7 @@
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
 
-PYTHONPATH=../ubuntu-sso-client/:../ubuntuone-storage-protocol:../ubuntuone-dev-tools:$PYTHONPATH
+PYTHONPATH=../ubuntu-sso-client/:../ubuntuone-storage-protocol:../ubuntuone-dev-tools:../ubuntuone-fsevents-daemon/python:$PYTHONPATH
 
 set -e
 if [ $# -ne 0 ]; then

=== renamed file 'tests/platform/filesystem_notifications/test_windows.py' => 'tests/platform/filesystem_notifications/common.py'
--- tests/platform/filesystem_notifications/test_windows.py	2012-07-18 15:18:04 +0000
+++ tests/platform/filesystem_notifications/common.py	2012-08-22 18:22:29 +0000
@@ -38,42 +38,45 @@
 import itertools
 
 from twisted.internet import defer
-from win32file import FILE_NOTIFY_INFORMATION
-
 from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.platform.os_helper import windows as os_helper
 from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
+    EventsCodes,
     ProcessEvent,
     IN_CLOSE_WRITE,
     IN_CREATE,
     IN_DELETE,
     IN_OPEN,
 )
-from ubuntuone.platform.filesystem_notifications.monitor import (
-    windows as filesystem_notifications,
-)
 from ubuntuone.platform.filesystem_notifications import notify_processor
 from ubuntuone.platform.filesystem_notifications.monitor.common import (
     FilesystemMonitor,
     Watch,
     WatchManager,
 )
-from ubuntuone.platform.filesystem_notifications.monitor.windows import (
-    ACTIONS,
-    FILE_NOTIFY_CHANGE_FILE_NAME,
-    FILE_NOTIFY_CHANGE_DIR_NAME,
-    FILE_NOTIFY_CHANGE_ATTRIBUTES,
-    FILE_NOTIFY_CHANGE_SIZE,
-    FILE_NOTIFY_CHANGE_LAST_WRITE,
-    FILE_NOTIFY_CHANGE_SECURITY,
-    FILE_NOTIFY_CHANGE_LAST_ACCESS,
-)
+from ubuntuone.platform.filesystem_notifications.monitor import ACTIONS
+from ubuntuone.platform.os_helper import get_os_valid_path
+
+OP_FLAGS = EventsCodes.FLAG_COLLECTIONS['OP_FLAGS']
+IS_DIR = EventsCodes.FLAG_COLLECTIONS['SPECIAL_FLAGS']['IN_ISDIR']
 
 #create a rever mapping to use it in the tests.
-REVERSE_WINDOWS_ACTIONS = {}
-for key, value in ACTIONS.iteritems():
-    REVERSE_WINDOWS_ACTIONS[value] = key
+REVERSE_OS_ACTIONS = {}
+for key, value in ACTIONS.items():
+    REVERSE_OS_ACTIONS[value] = key
+
+
+class FakeEventsProcessor(object):
+
+    """Handle fake events creation and processing."""
+
+    def create_fake_event(self):
+        """Create a fake filesystem event."""
+        raise NotImplementedError
+
+    def custom_process_events(self):
+        """Process a fake event."""
+        raise NotImplementedError
 
 
 class FakeException(Exception):
@@ -127,32 +130,17 @@
     @defer.inlineCallbacks
     def setUp(self):
         yield super(TestWatch, self).setUp()
+        self.path = ''
+        self.invalid_path = ''
+        self.common_path = ''
         self.basedir = self.mktemp('test_root')
-        self.mask = FILE_NOTIFY_CHANGE_FILE_NAME | \
-            FILE_NOTIFY_CHANGE_DIR_NAME | \
-            FILE_NOTIFY_CHANGE_ATTRIBUTES | \
-            FILE_NOTIFY_CHANGE_SIZE | \
-            FILE_NOTIFY_CHANGE_LAST_WRITE | \
-            FILE_NOTIFY_CHANGE_SECURITY | \
-            FILE_NOTIFY_CHANGE_LAST_ACCESS
+        self.mask = None
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)
         self.raw_events = []
         self.paths_checked = []
         old_is_dir = Watch._path_is_dir
-
-        def file_notify_information_wrapper(buf, data):
-            """Wrapper that gets the events and adds them to the list."""
-            events = FILE_NOTIFY_INFORMATION(buf, data)
-            # we want to append the list because that is what will be logged.
-            # If we use extend we wont have the same logging because it will
-            # group all events in a single lists which is not what the COM API
-            # does.
-            str_events = [
-                (filesystem_notifications.ACTIONS_NAMES[action], path) for action, path in
-                 events]
-            self.raw_events.append(str_events)
-            return events
+        self.fake_events_processor = FakeEventsProcessor()
 
         def path_is_dir_wrapper(watch, path):
             """Wrapper that gets the checked paths."""
@@ -160,8 +148,6 @@
             self.paths_checked.append((path, result))
             return result
 
-        self.patch(filesystem_notifications, 'FILE_NOTIFY_INFORMATION',
-                   file_notify_information_wrapper)
         self.patch(Watch, '_path_is_dir', path_is_dir_wrapper)
 
     @defer.inlineCallbacks
@@ -169,7 +155,7 @@
         """Perform the file operations and returns the recorded events."""
         handler = TestCaseHandler(number_events=number_events)
         manager = WatchManager(handler)
-        yield manager.add_watch(os_helper.get_windows_valid_path(path), mask)
+        yield manager.add_watch(get_os_valid_path(path), mask)
         # change the logger so that we can check the logs if we wanted
         manager._wdm[0].log.addHandler(self.memento)
         # clean logger later
@@ -198,7 +184,7 @@
             create_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(0x100, event.mask)
+        self.assertEqual(OP_FLAGS['IN_CREATE'], event.mask)
         self.assertEqual('IN_CREATE', event.maskname)
         self.assertEqual(os.path.split(file_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -218,7 +204,7 @@
             create_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(0x40000100, event.mask)
+        self.assertEqual(OP_FLAGS['IN_CREATE'] | IS_DIR, event.mask)
         self.assertEqual('IN_CREATE|IN_ISDIR', event.maskname)
         self.assertEqual(os.path.split(dir_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -240,7 +226,7 @@
                                                 remove_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(0x200, event.mask)
+        self.assertEqual(OP_FLAGS['IN_DELETE'], event.mask)
         self.assertEqual('IN_DELETE', event.maskname)
         self.assertEqual(os.path.split(file_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -262,36 +248,15 @@
                                                 remove_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(0x40000200, event.mask)
+        self.assertEqual(OP_FLAGS['IN_DELETE'] | IS_DIR, event.mask)
         self.assertEqual('IN_DELETE|IN_ISDIR', event.maskname)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
 
-    @defer.inlineCallbacks
     def test_file_write(self):
         """Test that the correct event is raised when a file is written."""
-        file_name = os.path.join(self.basedir, 'test_file_write')
-        # create the file before recording
-        fd = open(file_name, 'w')
-        # clean behind us by removing the file
-        self.addCleanup(os.remove, file_name)
-
-        def write_file():
-            """Action for the test."""
-            fd.write('test')
-            fd.close()
-
-        events = yield self._perform_operations(self.basedir, self.mask,
-                                                write_file, 1)
-        event = events[0]
-        self.assertFalse(event.dir)
-        self.assertEqual(0x2, event.mask)
-        self.assertEqual('IN_MODIFY', event.maskname)
-        self.assertEqual(os.path.split(file_name)[1], event.name)
-        self.assertEqual('.', event.path)
-        self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
-        self.assertEqual(0, event.wd)
+        raise NotImplementedError
 
     @defer.inlineCallbacks
     def test_file_moved_to_watched_dir_same_watcher(self):
@@ -313,7 +278,7 @@
         move_to_event = events[1]
         # first test the move from
         self.assertFalse(move_from_event.dir)
-        self.assertEqual(0x40, move_from_event.mask)
+        self.assertEqual(OP_FLAGS['IN_MOVED_FROM'], move_from_event.mask)
         self.assertEqual('IN_MOVED_FROM', move_from_event.maskname)
         self.assertEqual(os.path.split(from_file_name)[1],
                          move_from_event.name)
@@ -323,7 +288,7 @@
         self.assertEqual(0, move_from_event.wd)
         # test the move to
         self.assertFalse(move_to_event.dir)
-        self.assertEqual(0x80, move_to_event.mask)
+        self.assertEqual(OP_FLAGS['IN_MOVED_TO'], move_to_event.mask)
         self.assertEqual('IN_MOVED_TO', move_to_event.maskname)
         self.assertEqual(os.path.split(to_file_name)[1], move_to_event.name)
         self.assertEqual('.', move_to_event.path)
@@ -354,7 +319,7 @@
                                                 move_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(0x200, event.mask)
+        self.assertEqual(OP_FLAGS['IN_DELETE'], event.mask)
         self.assertEqual('IN_DELETE', event.maskname)
         self.assertEqual(os.path.split(from_file_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -382,7 +347,7 @@
                                                 move_files, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(0x100, event.mask)
+        self.assertEqual(OP_FLAGS['IN_CREATE'], event.mask)
         self.assertEqual('IN_CREATE', event.maskname)
         self.assertEqual(os.path.split(to_file_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -409,7 +374,8 @@
         move_to_event = events[1]
         # first test the move from
         self.assertTrue(move_from_event.dir)
-        self.assertEqual(0x40000040, move_from_event.mask)
+        self.assertEqual(OP_FLAGS['IN_MOVED_FROM'] | IS_DIR,
+            move_from_event.mask)
         self.assertEqual('IN_MOVED_FROM|IN_ISDIR', move_from_event.maskname)
         self.assertEqual(os.path.split(from_dir_name)[1], move_from_event.name)
         self.assertEqual('.', move_from_event.path)
@@ -418,7 +384,7 @@
         self.assertEqual(0, move_from_event.wd)
         # test the move to
         self.assertTrue(move_to_event.dir)
-        self.assertEqual(0x40000080, move_to_event.mask)
+        self.assertEqual(OP_FLAGS['IN_MOVED_TO'] | IS_DIR, move_to_event.mask)
         self.assertEqual('IN_MOVED_TO|IN_ISDIR', move_to_event.maskname)
         self.assertEqual(os.path.split(to_dir_name)[1], move_to_event.name)
         self.assertEqual('.', move_to_event.path)
@@ -447,7 +413,7 @@
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(0x40000200, event.mask)
+        self.assertEqual(OP_FLAGS['IN_DELETE'] | IS_DIR, event.mask)
         self.assertEqual('IN_DELETE|IN_ISDIR', event.maskname)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
@@ -471,7 +437,7 @@
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(0x40000100, event.mask)
+        self.assertEqual(OP_FLAGS['IN_CREATE'] | IS_DIR, event.mask)
         self.assertEqual('IN_CREATE|IN_ISDIR', event.maskname)
         self.assertEqual(os.path.split(from_dir_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -484,8 +450,9 @@
         handler = TestCaseHandler(number_events=0)
         manager = WatchManager(handler)
         # add a watch that will always exclude all actions
-        manager.add_watch(os_helper.get_windows_valid_path(self.basedir),
-                          self.mask, exclude_filter=lambda x: True)
+        manager.add_watch(get_os_valid_path(self.basedir),
+                          self.mask, auto_add=True,
+                          exclude_filter=lambda x: True)
         # execution the actions
         file_name = os.path.join(self.basedir, 'test_file_create')
         open(file_name, 'w').close()
@@ -502,16 +469,18 @@
             """Memorize the processed events."""
             events.append(event)
 
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        child = u'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
+        child = 'child'
+        watch = Watch(1, self.path, None)
+        watch.ignore_path(os.path.join(self.path, child))
         paths_to_ignore = []
         for file_name in 'abcdef':
-            paths_to_ignore.append((1, os.path.join(child, file_name)))
+            paths_to_ignore.append(
+                self.fake_events_processor.create_fake_event(
+                os.path.join(child, file_name)))
         # ensure that the watch is watching
-        watch._watching = True
-        watch.platform_watch._process_events(paths_to_ignore)
+        watch.platform_watch.watching = True
+        self.fake_events_processor.custom_process_events(
+            watch, paths_to_ignore)
         self.assertEqual(0, len(events),
                          'All events should have been ignored.')
 
@@ -523,17 +492,18 @@
             """Memorize the processed events."""
             events.append(event)
 
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        child = u'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
+        child = 'child'
+        watch = Watch(1, self.path, fake_processor)
+        watch.ignore_path(os.path.join(self.path, child))
         paths_not_to_ignore = []
         for file_name in 'abcdef':
-            paths_not_to_ignore.append((1, os.path.join(
-                                                child + file_name, file_name)))
+            event = self.fake_events_processor.create_fake_event(
+                os.path.join(child + file_name, file_name))
+            paths_not_to_ignore.append(event)
         # ensure that the watch is watching
         watch.platform_watch.watching = True
-        watch.platform_watch._process_events(paths_not_to_ignore)
+        self.fake_events_processor.custom_process_events(
+            watch, paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'No events should have been ignored.')
 
@@ -545,21 +515,22 @@
             """Memorize the processed events."""
             events.append(event.pathname)
 
-        child = u'child'
-        path = u'\\\\?\\C:\\path\\'  # a valid windows path
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
+        child = 'child'
+        watch = Watch(1, self.path, fake_processor)
+        watch.ignore_path(os.path.join(self.path, child))
         paths_not_to_ignore = []
         paths_to_ignore = []
         expected_events = []
         for file_name in 'abcdef':
             valid = os.path.join(child + file_name, file_name)
             paths_to_ignore.append((1, os.path.join(child, file_name)))
-            paths_not_to_ignore.append((1, valid))
-            expected_events.append(os.path.join('C:\\path', valid))
+            paths_not_to_ignore.append(
+                self.fake_events_processor.create_fake_event(valid))
+            expected_events.append(os.path.join(self.common_path, valid))
         # ensure that the watch is watching
         watch.platform_watch.watching = True
-        watch.platform_watch._process_events(paths_not_to_ignore)
+        self.fake_events_processor.custom_process_events(
+            watch, paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'Wrong number of events ignored.')
         self.assertTrue(all([event in expected_events for event in events]),
@@ -573,17 +544,19 @@
             """Memorize the processed events."""
             events.append(event)
 
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        child = u'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
-        watch.remove_ignored_path(os.path.join(path, child))
+        child = 'child'
+        watch = Watch(1, self.path, fake_processor)
+        watch.ignore_path(os.path.join(self.path, child))
+        watch.remove_ignored_path(os.path.join(self.path, child))
         paths_not_to_ignore = []
         for file_name in 'abcdef':
-            paths_not_to_ignore.append((1, os.path.join(child, file_name)))
+            event = self.fake_events_processor.create_fake_event(
+                os.path.join(child, file_name))
+            paths_not_to_ignore.append(event)
         # ensure that the watch is watching
         watch.platform_watch.watching = True
-        watch.platform_watch._process_events(paths_not_to_ignore)
+        self.fake_events_processor.custom_process_events(
+            watch, paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
 
@@ -595,190 +568,98 @@
             """Memorize the processed events."""
             events.append(event.pathname)
 
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        child_a = u'childa'
-        child_b = u'childb'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child_a))
-        watch.ignore_path(os.path.join(path, child_b))
-        watch.remove_ignored_path(os.path.join(path, child_a))
+        child_a = 'childa'
+        child_b = 'childb'
+        watch = Watch(1, self.path, fake_processor)
+        watch.ignore_path(os.path.join(self.path, child_a))
+        watch.ignore_path(os.path.join(self.path, child_b))
+        watch.remove_ignored_path(os.path.join(self.path, child_a))
         paths_to_ignore = []
         paths_not_to_ignore = []
         expected_events = []
         for file_name in 'abcdef':
             paths_to_ignore.append((1, os.path.join(child_b, file_name)))
             valid = os.path.join(child_a, file_name)
-            paths_not_to_ignore.append((1, valid))
-            expected_events.append(os.path.join('C:\\path', valid))
+            event = self.fake_events_processor.create_fake_event(valid)
+            paths_not_to_ignore.append(event)
+            expected_events.append(os.path.join(self.common_path, valid))
         # ensure that the watch is watching
         watch.platform_watch.watching = True
-        watch.platform_watch._process_events(paths_not_to_ignore)
+        self.fake_events_processor.custom_process_events(
+            watch, paths_not_to_ignore)
         self.assertEqual(len(paths_not_to_ignore), len(events),
                          'All events should have been accepted.')
         self.assertTrue(all([event in expected_events for event in events]),
                         'Paths ignored that should have not been ignored.')
 
-    @defer.inlineCallbacks
-    def test_call_deferred_already_called(self):
-        """Test that the function is not called."""
-        method_args = []
-
-        def fake_call(*args, **kwargs):
-            """Execute the call."""
-            method_args.append((args, kwargs),)
-
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None)
-        yield watch.platform_watch._watch_started_deferred.callback(True)
-        watch.platform_watch._call_deferred(fake_call, None)
-        self.assertEqual(0, len(method_args))
-
-    def test_call_deferred_not_called(self):
-        """Test that is indeed called."""
-        method_args = []
-
-        def fake_call(*args, **kwargs):
-            """Execute the call."""
-            method_args.append((args, kwargs),)
-
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None)
-        watch.platform_watch._call_deferred(fake_call, None)
-        self.assertEqual(1, len(method_args))
-
-    def test_started_property(self):
-        """Test that the started property returns the started deferred."""
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None)
-        self.assertEqual(watch.started, watch.platform_watch._watch_started_deferred)
-
-    def test_stopped_property(self):
-        """Test that the stopped property returns the stopped deferred."""
-        path = u'\\\\?\\C:\\path'  # a valid windows path
-        watch = Watch(1, path, None)
-        self.assertEqual(watch.stopped, watch.platform_watch._watch_stopped_deferred)
-
     def random_error(self, *args):
         """Throw a fake exception."""
         raise FakeException()
 
-    @defer.inlineCallbacks
-    def test_start_watching_fails_early_in_thread(self):
-        """An early failure inside the thread should errback the deferred."""
-        test_path = self.mktemp("test_directory")
-        self.patch(filesystem_notifications, "CreateFileW", self.random_error)
-        watch = Watch(1, test_path, None)
-        d = watch.start_watching()
-        yield self.assertFailure(d, FakeException)
-
-    @defer.inlineCallbacks
-    def test_start_watching_fails_late_in_thread(self):
-        """A late failure inside the thread should errback the deferred."""
-        test_path = self.mktemp("test_directory")
-        self.patch(filesystem_notifications, "ReadDirectoryChangesW",
-                   self.random_error)
-        watch = Watch(1, test_path, None)
-        d = watch.start_watching()
-        yield self.assertFailure(d, FakeException)
-
-    @defer.inlineCallbacks
-    def test_close_handle_is_called_on_error(self):
-        """CloseHandle is called when there's an error in the watch thread."""
-        test_path = self.mktemp("test_directory")
-        close_called = []
-        self.patch(filesystem_notifications, "CreateFileW", lambda *_: None)
-        self.patch(filesystem_notifications, "CloseHandle",
-                   close_called.append)
-        self.patch(filesystem_notifications, "ReadDirectoryChangesW",
-                   self.random_error)
-        watch = Watch(1, test_path, None)
-        d = watch.start_watching()
-        yield self.assertFailure(d, FakeException)
-        self.assertEqual(len(close_called), 1)
-        yield watch.stop_watching()
-
-    @defer.inlineCallbacks
-    def test_stop_watching_fired_when_watch_thread_finishes(self):
-        """The deferred returned is fired when the watch thread finishes."""
-        test_path = self.mktemp("another_test_directory")
-        watch = Watch(1, test_path, None)
-        yield watch.start_watching()
-        self.assertNotEqual(watch.platform_watch._watch_handle, None)
-        yield watch.stop_watching()
-        self.assertEqual(watch.platform_watch._watch_handle, None)
-
     def test_is_path_dir_missing_no_subdir(self):
         """Test when the path does not exist and is no a subdir."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
         watch = Watch(1, test_path, None)
-        self.assertFalse(watch._path_is_dir(path))
+        self.assertFalse(watch._path_is_dir(self.invalid_path))
 
     def test_is_path_dir_missing_in_subdir(self):
         """Test when the path does not exist and is a subdir."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: False)
         watch = Watch(1, test_path, None)
-        watch._subdirs.add(path)
-        self.assertTrue(watch._path_is_dir(path))
+        watch._subdirs.add(self.invalid_path)
+        self.assertTrue(watch._path_is_dir(self.invalid_path))
 
     def test_is_path_dir_present_is_dir(self):
         """Test when the path is present and is dir."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: True)
         watch = Watch(1, test_path, None)
-        watch._subdirs.add(path)
-        self.assertTrue(watch._path_is_dir(path))
+        watch._subdirs.add(self.invalid_path)
+        self.assertTrue(watch._path_is_dir(self.invalid_path))
 
     def test_is_path_dir_present_no_dir(self):
         """Test when the path is present but not a dir."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         self.patch(os.path, 'exists', lambda path: True)
         self.patch(os.path, 'isdir', lambda path: False)
         watch = Watch(1, test_path, None)
-        watch._subdirs.add(path)
-        self.assertFalse(watch._path_is_dir(path))
+        watch._subdirs.add(self.invalid_path)
+        self.assertFalse(watch._path_is_dir(self.invalid_path))
 
     def test_update_subdirs_create_not_present(self):
         """Test when we update on a create event and not present."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         watch = Watch(1, test_path, None)
-        watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_CREATE])
-        self.assertTrue(path in watch._subdirs)
+        watch._update_subdirs(self.invalid_path, REVERSE_OS_ACTIONS[IN_CREATE])
+        self.assertTrue(self.invalid_path in watch._subdirs)
 
     def test_update_subdirs_create_present(self):
         """Test when we update on a create event and is present."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         watch = Watch(1, test_path, None)
-        watch._subdirs.add(path)
+        watch._subdirs.add(self.invalid_path)
         old_length = len(watch._subdirs)
-        watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_CREATE])
-        self.assertTrue(path in watch._subdirs)
+        watch._update_subdirs(self.invalid_path, REVERSE_OS_ACTIONS[IN_CREATE])
+        self.assertTrue(self.invalid_path in watch._subdirs)
         self.assertEqual(old_length, len(watch._subdirs))
 
     def test_update_subdirs_delete_not_present(self):
         """Test when we delete and is not present."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         watch = Watch(1, test_path, None)
-        watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_DELETE])
-        self.assertTrue(path not in watch._subdirs)
+        watch._update_subdirs(self.invalid_path, REVERSE_OS_ACTIONS[IN_DELETE])
+        self.assertTrue(self.invalid_path not in watch._subdirs)
 
     def test_update_subdirs_delete_present(self):
         """Test when we delete and is present."""
-        path = u'\\\\?\\C:\\path\\to\\no\\dir'
         test_path = self.mktemp("test_directory")
         watch = Watch(1, test_path, None)
-        watch._subdirs.add(path)
-        watch._update_subdirs(path, REVERSE_WINDOWS_ACTIONS[IN_DELETE])
-        self.assertTrue(path not in watch._subdirs)
+        watch._subdirs.add(self.invalid_path)
+        watch._update_subdirs(self.invalid_path, REVERSE_OS_ACTIONS[IN_DELETE])
+        self.assertTrue(self.invalid_path not in watch._subdirs)
 
 
 class TestWatchManager(BaseTwistedTestCase):
@@ -788,11 +669,8 @@
     def setUp(self):
         """Set each of the tests."""
         yield super(TestWatchManager, self).setUp()
-        self.parent_path = u'\\\\?\\C:\\'  # a valid windows path
-        self.path = self.parent_path + u'path'
-        self.watch = Watch(1, self.path, None)
         self.manager = WatchManager(None)
-        self.manager._wdm = {1: self.watch}
+        self.fake_events_processor = FakeEventsProcessor()
 
     @defer.inlineCallbacks
     def test_stop(self):
@@ -808,25 +686,9 @@
         yield self.manager.stop()
         self.assertTrue(self.was_called, 'The watch stop should be called.')
 
-    @defer.inlineCallbacks
     def test_stop_multiple(self):
         """Test that stop is fired when *all* watches have stopped."""
-
-        def fake_stop_watching(watch):
-            """Another fake stop watch."""
-            return watch.stopped
-
-        self.patch(Watch, "stop_watching", fake_stop_watching)
-        second_path = self.parent_path + u"second_path"
-        second_watch = Watch(2, second_path, None)
-        self.manager._wdm[2] = second_watch
-        d = self.manager.stop()
-        self.assertFalse(d.called, "Not fired before all watches end")
-        self.watch.stopped.callback(None)
-        self.assertFalse(d.called, "Not fired before all watches end")
-        second_watch.stopped.callback(None)
-        yield d
-        self.assertTrue(d.called, "Fired after the watches ended")
+        raise NotImplementedError
 
     def test_get_present_watch(self):
         """Test that we can get a Watch using is wd."""
@@ -836,7 +698,6 @@
         """Test that we get an error when trying to get a missing wd."""
         self.assertRaises(KeyError, self.manager.get_watch, (1,))
 
-    @defer.inlineCallbacks
     def test_delete_present_watch(self):
         """Test that we can remove a present watch."""
         self.was_called = False
@@ -865,7 +726,6 @@
         self.manager.add_watch(self.path, mask)
         self.assertEqual(1, len(self.manager._wdm))
         self.assertTrue(self.was_called, 'The watch start was not called.')
-        self.assertEqual(self.path + os.path.sep, self.manager._wdm[0].path)
 
     def test_get_watch_present_wd(self):
         """Test that the correct path is returned."""
@@ -889,10 +749,8 @@
         """A watch on an unwatched path returns None."""
         self.assertEqual(None, self.manager.get_wd(self.parent_path))
 
-    @defer.inlineCallbacks
     def test_rm_present_wd(self):
         """Test the removal of a present watch."""
-
         def fake_stop_watching():
             """Fake stop watch."""
             return defer.succeed(True)
@@ -913,8 +771,9 @@
         self.manager.rm_path(self.path)
         self.assertEqual(self.watch, self.manager._wdm.get(1))
         self.watch._watching = True
-        self.watch.platform_watch._process_events(
-                [(1, os.path.join(self.path, 'test'))])
+        event = self.fake_events_processor.create_fake_event(
+            os.path.join(self.path, 'test'))
+        self.fake_events_processor.custom_process_events(self.watch, [event])
         self.assertEqual(0, len(events))
 
     def test_rm_child_path(self):
@@ -926,41 +785,27 @@
             events.append(event.pathname)
 
         self.watch._processor = fake_processor
-        child = os.path.join(self.path, u'child')
+        child = os.path.join(self.path, 'child')
         self.manager.rm_path(child)
         self.assertEqual(self.watch, self.manager._wdm[1])
         # assert that the correct event is ignored
         self.watch.platform_watch.watching = True
-        self.watch.platform_watch._process_events(
-                [(1, os.path.join('child', 'test'))])
+        event = self.fake_events_processor.create_fake_event(
+            os.path.join('child', 'test'))
+        self.fake_events_processor.custom_process_events(self.watch, [event])
         self.assertEqual(0, len(events))
         # assert that other events are not ignored
-        self.watch.platform_watch._process_events([(1, 'test')])
+        event2 = self.fake_events_processor.create_fake_event('test')
+        self.fake_events_processor.custom_process_events(self.watch, [event2])
         self.assertEqual(1, len(events))
 
 
 class TestWatchManagerAddWatches(BaseTwistedTestCase):
     """Test the watch manager."""
-    timeout = 5
 
     def test_add_watch_twice(self):
         """Adding a watch twice succeeds when the watch is running."""
-        self.patch(Watch, "start_watching", lambda self: self.started)
-        manager = WatchManager(None)
-        # no need to stop watching because start_watching is fake
-
-        path = u'\\\\?\\C:\\test'  # a valid windows path
-        mask = 'fake bit mask'
-        d1 = manager.add_watch(path, mask)
-        d2 = manager.add_watch(path, mask)
-
-        self.assertFalse(d1.called, "Should not be called yet.")
-        self.assertFalse(d2.called, "Should not be called yet.")
-
-        manager._wdm.values()[0].started.callback(True)
-
-        self.assertTrue(d1.called, "Should already be called.")
-        self.assertTrue(d2.called, "Should already be called.")
+        raise NotImplementedError
 
 
 class FakeEvent(object):
@@ -1083,16 +928,6 @@
         self.assertEqual(event, self.general.called_methods[0][1])
         self.assertEqual(paths, self.general.called_methods[0][2])
 
-    def test_platform_is_ignored(self):
-        """Test that we do indeed ignore the correct paths."""
-        not_ignored = 'test'
-        ignored = not_ignored + '.lnk'
-        path_is_ignored = notify_processor.common.path_is_ignored
-        self.assertFalse(path_is_ignored(not_ignored),
-                         'Only links should be ignored.')
-        self.assertTrue(path_is_ignored(ignored),
-                         'Links should be ignored.')
-
     def test_is_ignored(self):
         """Test that we do ensure that the path is ignored."""
         path = 'path'
@@ -1406,31 +1241,15 @@
 
 class FilesystemMonitorTestCase(BaseTwistedTestCase):
     """Tests for the FilesystemMonitor."""
+
     timeout = 5
 
     def test_add_watch_twice(self):
         """Check the deferred returned by a second add_watch."""
-        self.patch(Watch, "start_watching", lambda self: self.started)
-        monitor = FilesystemMonitor(None, None)
-        # no need to stop watching because start_watching is fake
-
-        parent_path = 'C:\\test'  # a valid windows path in utf-8 bytes
-        child_path = parent_path + "\\child"
-        d1 = monitor.add_watch(parent_path)
-        d2 = monitor.add_watch(child_path)
-
-        self.assertFalse(d1.called, "Should not be called yet.")
-        self.assertFalse(d2.called, "Should not be called yet.")
-
-        monitor._watch_manager._wdm.values()[0].started.callback(True)
-
-        self.assertTrue(d1.called, "Should already be called.")
-        self.assertTrue(d2.called, "Should already be called.")
-
-    @defer.inlineCallbacks
+        raise NotImplementedError
+
     def test_add_watches_to_udf_ancestors(self):
         """Test that the ancestor watches are not added."""
-
         class FakeVolume(object):
             """A fake UDF."""
 

=== modified file 'tests/platform/filesystem_notifications/test_darwin.py'
--- tests/platform/filesystem_notifications/test_darwin.py	2012-07-18 15:18:04 +0000
+++ tests/platform/filesystem_notifications/test_darwin.py	2012-08-22 18:22:29 +0000
@@ -28,16 +28,13 @@
 # files in the program, then also delete it here.
 """Test the filesystem notifications on MAC OS."""
 
+import itertools
 import logging
 import os
 import tempfile
 import thread
-import itertools
 
-import fsevents
 from twisted.internet import defer
-
-from contrib.testing.testcase import BaseTwistedTestCase
 from ubuntuone.devtools.handlers import MementoHandler
 from ubuntuone.platform.filesystem_notifications.monitor import (
     common,
@@ -51,7 +48,6 @@
     WatchManager,
 )
 from ubuntuone.platform.filesystem_notifications.pyinotify_agnostic import (
-    EventsCodes,
     ProcessEvent,
     IN_CLOSE_WRITE,
     IN_CREATE,
@@ -59,6 +55,7 @@
     IN_OPEN,
 )
 from tests.platform.filesystem_notifications import BaseFSMonitorTestCase
+from tests.platform.filesystem_notifications import common as common_tests
 
 
 # A reverse mapping for the tests
@@ -67,23 +64,18 @@
     REVERSE_MACOS_ACTIONS[value] = key
 
 
-OP_FLAGS = EventsCodes.FLAG_COLLECTIONS['OP_FLAGS']
-IS_DIR = EventsCodes.FLAG_COLLECTIONS['SPECIAL_FLAGS']['IN_ISDIR']
-
-
-class FakeException(Exception):
-    """A fake Exception used in tests."""
-
-
-class FakeVolume(object):
-    """A fake volume."""
-
-    def __init__(self, path, ancestors):
-        """Create a new instance."""
-        super(FakeVolume, self).__init__()
-        self.volume_id = path
-        self.path = path
-        self.ancestors = ancestors
+class FakeEventsProcessor(object):
+
+    """Handle fake events creation and processing."""
+
+    def create_fake_event(self, filename):
+        """Create a fake file event."""
+        return FakeFileEvent(256, None, filename)
+
+    def custom_process_events(self, watch, events):
+        """Adapt to each platform way to process events."""
+        for event in events:
+            watch.platform_watch._process_events(event)
 
 
 class FakeFileEvent(object):
@@ -135,7 +127,7 @@
             assert self.main_thread_id == thread.get_ident()
 
 
-class TestWatch(BaseTwistedTestCase):
+class TestWatch(common_tests.TestWatch):
     """Test the watch so that it returns the same events as pyinotify."""
 
     timeout = 5
@@ -143,6 +135,9 @@
     @defer.inlineCallbacks
     def setUp(self):
         yield super(TestWatch, self).setUp()
+        self.path = '/Users/username/folder'
+        self.common_path = '/Users/username/folder'
+        self.invalid_path = '/Users/username/path/to/not/dir'
         self.basedir = self.mktemp('test_root')
         self.mask = None
         self.stream = None
@@ -151,6 +146,7 @@
         self.raw_events = []
         self.paths_checked = []
         old_is_dir = Watch._path_is_dir
+        self.fake_events_processor = FakeEventsProcessor()
 
         def path_is_dir_wrapper(watch, path):
             """Wrapper that gets the checked paths."""
@@ -158,37 +154,32 @@
             self.paths_checked.append((path, result))
             return result
 
-        self.patch(Watch, '_path_is_dir',
-                   path_is_dir_wrapper)
-
-    @defer.inlineCallbacks
-    def _perform_operations(self, path, mask, actions, number_events):
-        """Perform the file operations and returns the recorded events."""
-        handler = TestCaseHandler(number_events=number_events)
-        manager = WatchManager(handler)
-        yield manager.add_watch(path, mask)
-        # change the logger so that we can check the logs if we wanted
-        manager._wdm[0].log.addHandler(self.memento)
-        # clean logger later
-        self.addCleanup(manager._wdm[0].log.removeHandler, self.memento)
-        # execution the actions
-        actions()
-        # process the recorded events
-        ret = yield handler.deferred
-        self.addCleanup(manager.stop)
-        defer.returnValue(ret)
-
-    def _assert_logs(self, events):
-        """Assert the debug logs."""
-        logs = []
-        msg = 'Is path %r a dir? %s'
-        logs.extend([msg % data for data in self.paths_checked])
-        msg = 'Pushing event %r to processor.'
-        logs.extend([msg % e for e in events])
-        for msg in logs:
-            self.assertTrue(self.memento.check_debug(msg))
-
-    @defer.inlineCallbacks
+        self.patch(Watch, '_path_is_dir', path_is_dir_wrapper)
+
+    def test_not_ignore_path(self):
+        """Test that we do get the events when they do not match."""
+        self.patch(filesystem_notifications.reactor, 'callFromThread',
+            lambda x, e: x(e))
+        super(TestWatch, self).test_not_ignore_path()
+
+    def test_undo_ignore_path_ignored(self):
+        """Test that we do deal with events from and old ignored path."""
+        self.patch(filesystem_notifications.reactor, 'callFromThread',
+            lambda x, e: x(e))
+        super(TestWatch, self).test_not_ignore_path()
+
+    def test_undo_ignore_path_other_ignored(self):
+        """Test that we can undo and the other path is ignored."""
+        self.patch(filesystem_notifications.reactor, 'callFromThread',
+            lambda x, e: x(e))
+        super(TestWatch, self).test_not_ignore_path()
+
+    def test_mixed_ignore_path(self):
+        """Test that we do get the correct events."""
+        self.patch(filesystem_notifications.reactor, 'callFromThread',
+            lambda x, e: x(e))
+        super(TestWatch, self).test_mixed_ignore_path()
+
     def test_file_create(self):
         """Test that the correct event is returned on a file create."""
         file_name = os.path.join(self.basedir, 'test_file_create')
@@ -205,14 +196,12 @@
             create_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(OP_FLAGS['IN_CREATE'], event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_CREATE'], event.mask)
         self.assertEqual('IN_CREATE', event.maskname)
         self.assertEqual(os.path.split(file_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_create(self):
@@ -227,14 +216,13 @@
             create_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(OP_FLAGS['IN_CREATE'] | IS_DIR, event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_CREATE'] |
+            common_tests.IS_DIR, event.mask)
         self.assertEqual('IN_CREATE|IN_ISDIR', event.maskname)
         self.assertEqual(os.path.split(dir_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_remove(self):
@@ -251,14 +239,12 @@
                                                 remove_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(OP_FLAGS['IN_DELETE'], event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_DELETE'], event.mask)
         self.assertEqual('IN_DELETE', event.maskname)
         self.assertEqual(os.path.split(file_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_remove(self):
@@ -275,13 +261,12 @@
                                                 remove_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(OP_FLAGS['IN_DELETE'] | IS_DIR, event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_DELETE'] |
+            common_tests.IS_DIR, event.mask)
         self.assertEqual('IN_DELETE|IN_ISDIR', event.maskname)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_write(self):
@@ -301,14 +286,12 @@
                                                 write_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(OP_FLAGS['IN_CREATE'], event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_CREATE'], event.mask)
         self.assertEqual('IN_CREATE', event.maskname)
         self.assertEqual(os.path.split(file_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_moved_to_watched_dir_same_watcher(self):
@@ -330,7 +313,8 @@
         move_to_event = events[1]
         # first test the move from
         self.assertFalse(move_from_event.dir)
-        self.assertEqual(OP_FLAGS['IN_MOVED_FROM'], move_from_event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_MOVED_FROM'],
+            move_from_event.mask)
         self.assertEqual('IN_MOVED_FROM', move_from_event.maskname)
         self.assertEqual(os.path.split(from_file_name)[1],
                          move_from_event.name)
@@ -340,7 +324,8 @@
         self.assertEqual(0, move_from_event.wd)
         # test the move to
         self.assertFalse(move_to_event.dir)
-        self.assertEqual(OP_FLAGS['IN_MOVED_TO'], move_to_event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_MOVED_TO'],
+            move_to_event.mask)
         self.assertEqual('IN_MOVED_TO', move_to_event.maskname)
         self.assertEqual(os.path.split(to_file_name)[1], move_to_event.name)
         self.assertEqual('.', move_to_event.path)
@@ -351,8 +336,6 @@
         self.assertEqual(0, move_to_event.wd)
         # assert that both cookies are the same
         self.assertEqual(move_from_event.cookie, move_to_event.cookie)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_moved_to_not_watched_dir(self):
@@ -372,15 +355,13 @@
                                                 move_file, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(OP_FLAGS['IN_DELETE'], event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_DELETE'], event.mask)
         self.assertEqual('IN_DELETE', event.maskname)
         self.assertEqual(os.path.split(from_file_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, from_file_name),
                          event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_file_move_from_not_watched_dir(self):
@@ -402,15 +383,13 @@
                                                 move_files, 1)
         event = events[0]
         self.assertFalse(event.dir)
-        self.assertEqual(OP_FLAGS['IN_CREATE'], event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_CREATE'], event.mask)
         self.assertEqual('IN_CREATE', event.maskname)
         self.assertEqual(os.path.split(to_file_name)[1], event.name)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, to_file_name),
             event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_moved_to_watched_dir_same_watcher(self):
@@ -431,7 +410,8 @@
         move_to_event = events[1]
         # first test the move from
         self.assertTrue(move_from_event.dir)
-        self.assertEqual(OP_FLAGS['IN_MOVED_FROM'] | IS_DIR,
+        self.assertEqual(common_tests.OP_FLAGS['IN_MOVED_FROM'] |
+            common_tests.IS_DIR,
             move_from_event.mask)
         self.assertEqual('IN_MOVED_FROM|IN_ISDIR', move_from_event.maskname)
         self.assertEqual(os.path.split(from_dir_name)[1], move_from_event.name)
@@ -441,7 +421,8 @@
         self.assertEqual(0, move_from_event.wd)
         # test the move to
         self.assertTrue(move_to_event.dir)
-        self.assertEqual(OP_FLAGS['IN_MOVED_TO'] | IS_DIR, move_to_event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_MOVED_TO'] |
+            common_tests.IS_DIR, move_to_event.mask)
         self.assertEqual('IN_MOVED_TO|IN_ISDIR', move_to_event.maskname)
         self.assertEqual(os.path.split(to_dir_name)[1], move_to_event.name)
         self.assertEqual('.', move_to_event.path)
@@ -452,8 +433,6 @@
         self.assertEqual(0, move_to_event.wd)
         # assert that both cookies are the same
         self.assertEqual(move_from_event.cookie, move_to_event.cookie)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_moved_to_not_watched_dir(self):
@@ -473,13 +452,12 @@
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(OP_FLAGS['IN_DELETE'] | IS_DIR, event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_DELETE'] |
+            common_tests.IS_DIR, event.mask)
         self.assertEqual('IN_DELETE|IN_ISDIR', event.maskname)
         self.assertEqual('.', event.path)
         self.assertEqual(os.path.join(self.basedir, dir_name), event.pathname)
         self.assertEqual(0, event.wd)
-        # assert the logging
-        self._assert_logs(events)
 
     @defer.inlineCallbacks
     def test_dir_move_from_not_watched_dir(self):
@@ -499,7 +477,8 @@
                                                 move_dir, 1)
         event = events[0]
         self.assertTrue(event.dir)
-        self.assertEqual(OP_FLAGS['IN_CREATE'] | IS_DIR, event.mask)
+        self.assertEqual(common_tests.OP_FLAGS['IN_CREATE'] |
+            common_tests.IS_DIR, event.mask)
         self.assertEqual('IN_CREATE|IN_ISDIR', event.maskname)
         self.assertEqual(os.path.split(from_dir_name)[1], event.name)
         self.assertEqual('.', event.path)
@@ -521,149 +500,6 @@
         self.assertEqual(0, len(handler.processed_events))
     test_exclude_filter.skip = "we must rethink this test."
 
-    def test_ignore_path(self):
-        """Test that events from a path are ignored."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event)
-
-        path = '/Users/username/folder'
-        child = 'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
-        # ensure that the watch is watching
-        watch.platform_watch.watching = True
-        for file_name in 'abcdef':
-            event = FakeFileEvent(256, None, os.path.join(child, file_name))
-            watch.platform_watch._process_events(event)
-        self.assertEqual(0, len(events),
-                         'All events should have been ignored.')
-
-    def test_not_ignore_path(self):
-        """Test that we do get the events when they do not match."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event)
-
-        self.patch(filesystem_notifications.reactor, 'callFromThread',
-            lambda x, e: x(e))
-
-        path = '/Users/username/folder'
-        child = 'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
-        paths_not_to_ignore = []
-        for file_name in 'abcdef':
-            event = FakeFileEvent(256, None, os.path.join(child + file_name,
-                                  file_name))
-            paths_not_to_ignore.append(event)
-        # ensure that the watch is watching
-        watch.platform_watch.watching = True
-        for event in paths_not_to_ignore:
-            watch.platform_watch._process_events(event)
-        self.assertEqual(len(paths_not_to_ignore), len(events),
-                         'No events should have been ignored.')
-
-    def test_mixed_ignore_path(self):
-        """Test that we do get the correct events."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event.pathname)
-
-        self.patch(filesystem_notifications.reactor, 'callFromThread',
-            lambda x, e: x(e))
-
-        child = 'child'
-        path = '/Users/username/folder'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
-        paths_not_to_ignore = []
-        paths_to_ignore = []
-        expected_events = []
-        for file_name in 'abcdef':
-            valid = os.path.join(child + file_name, file_name)
-            paths_to_ignore.append((1, os.path.join(child, file_name)))
-            event = FakeFileEvent(256, None, valid)
-            paths_not_to_ignore.append(event)
-            expected_events.append(os.path.join(path, valid))
-        # ensure that the watch is watching
-        watch.platform_watch.watching = True
-        for event in paths_not_to_ignore:
-            watch.platform_watch._process_events(event)
-        self.assertEqual(len(paths_not_to_ignore), len(events),
-                         'Wrong number of events ignored.')
-        self.assertTrue(all([event in expected_events for event in events]),
-                        'Paths ignored that should have not been ignored.')
-
-    def test_undo_ignore_path_ignored(self):
-        """Test that we do deal with events from and old ignored path."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event)
-
-        self.patch(filesystem_notifications.reactor, 'callFromThread',
-            lambda x, e: x(e))
-
-        path = '/Users/username/folder'
-        child = 'child'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child))
-        watch.remove_ignored_path(os.path.join(path, child))
-        paths_not_to_ignore = []
-        for file_name in 'abcdef':
-            event = FakeFileEvent(256, None, os.path.join(child, file_name))
-            paths_not_to_ignore.append(event)
-        # ensure that the watch is watching
-        watch.platform_watch.watching = True
-        for event in paths_not_to_ignore:
-            watch.platform_watch._process_events(event)
-        self.assertEqual(len(paths_not_to_ignore), len(events),
-                         'All events should have been accepted.')
-
-    def test_undo_ignore_path_other_ignored(self):
-        """Test that we can undo and the other path is ignored."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event.pathname)
-
-        self.patch(filesystem_notifications.reactor, 'callFromThread',
-            lambda x, e: x(e))
-
-        path = '/Users/username/folder'
-        child_a = 'childa'
-        child_b = 'childb'
-        watch = Watch(1, path, fake_processor)
-        watch.ignore_path(os.path.join(path, child_a))
-        watch.ignore_path(os.path.join(path, child_b))
-        watch.remove_ignored_path(os.path.join(path, child_a))
-        paths_to_ignore = []
-        paths_not_to_ignore = []
-        expected_events = []
-        for file_name in 'abcdef':
-            paths_to_ignore.append((1, os.path.join(child_b, file_name)))
-            valid = os.path.join(child_a, file_name)
-            event = FakeFileEvent(256, None, valid)
-            paths_not_to_ignore.append(event)
-            expected_events.append(os.path.join(path, valid))
-        # ensure that the watch is watching
-        watch.platform_watch.watching = True
-        for event in paths_not_to_ignore:
-            watch.platform_watch._process_events(event)
-        self.assertEqual(len(paths_not_to_ignore), len(events),
-                         'All events should have been accepted.')
-        self.assertTrue(all([event in expected_events for event in events]),
-                        'Paths ignored that should have not been ignored.')
-
     def test_stream_created(self):
         """Test that the stream is created."""
         def fake_call(*args, **kwargs):
@@ -684,7 +520,7 @@
 
     def random_error(self, *args):
         """Throw a fake exception."""
-        raise FakeException()
+        raise common_tests.FakeException()
 
     def test_is_path_dir_missing_no_subdir(self):
         """Test when the path does not exist and is no a subdir."""
@@ -760,7 +596,7 @@
         self.assertTrue(path not in watch._subdirs)
 
 
-class TestWatchManager(BaseTwistedTestCase):
+class TestWatchManager(common_tests.TestWatchManager):
     """Test the watch manager."""
 
     @defer.inlineCallbacks
@@ -772,24 +608,19 @@
         self.watch = Watch(1, self.path, None)
         self.manager = WatchManager(None)
         self.manager._wdm = {1: self.watch}
+        self.stream = None
+        self.fake_events_processor = FakeEventsProcessor()
 
     @defer.inlineCallbacks
     def test_stop(self):
         """Test that the different watches are stopped."""
-        self.was_called = False
-
-        def fake_stop_watching(watch):
-            """Fake stop watch."""
-            self.was_called = True
-            return defer.succeed(True)
-
-        self.patch(Watch, "stop_watching", fake_stop_watching)
+        self.patch(self.manager.manager.observer, "unschedule",
+            lambda x: None)
         self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
-        yield self.manager.stop()
-        self.assertTrue(self.was_called, 'The watch stop should be called.')
+        yield super(TestWatchManager, self).test_stop()
 
     def test_stop_multiple(self):
-        """The watches should became watching=False and the observer stopped."""
+        """Watches should became watching=False and the observer stopped."""
         self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
         second_path = self.parent_path + "second_path"
         second_watch = Watch(2, second_path, None)
@@ -810,28 +641,6 @@
         """Test that we get an error when trying to get a missing wd."""
         self.assertRaises(KeyError, self.manager.get_watch, (1,))
 
-    @defer.inlineCallbacks
-    def test_delete_present_watch(self):
-        """Test that we can remove a present watch."""
-        self.was_called = False
-
-        def stop_watching():
-            """Fake stop watch."""
-            self.was_called = True
-            return defer.succeed(True)
-
-        def fake_unschedule(s):
-            """Fake function that should receive a Stream object."""
-            self.stream = s
-
-        self.patch(self.manager.manager.observer, "unschedule",
-            fake_unschedule)
-
-        self.watch.stop_watching = stop_watching
-        yield self.manager.del_watch(1)
-        self.assertIsInstance(self.stream, fsevents.Stream)
-        self.assertRaises(KeyError, self.manager.get_watch, (1,))
-
     def test_add_single_watch(self):
         """Test the addition of a new single watch."""
         self.was_called = False
@@ -849,10 +658,6 @@
         self.assertTrue(self.was_called, 'The watch start was not called.')
         self.assertEqual(self.path + os.path.sep, self.manager._wdm[0].path)
 
-    def test_get_watch_present_wd(self):
-        """Test that the correct path is returned."""
-        self.assertEqual(self.path + os.path.sep, self.manager.get_path(1))
-
     def test_get_watch_missing_wd(self):
         """Test that the correct path is returned."""
         self.manager._wdm = {}
@@ -873,60 +678,24 @@
 
     def test_rm_present_wd(self):
         """Test the removal of a present watch."""
-        self.patch(self.watch, "stop_watching", lambda: None)
         self.patch(self.manager.manager.observer, "unschedule", lambda x: None)
-        self.manager.rm_watch(1)
-        self.assertEqual(None, self.manager._wdm.get(1))
-
-    def test_rm_root_path(self):
-        """Test the removal of a root path."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event.pathname)
-
-        self.watch._processor = fake_processor
-        self.manager.rm_path(self.path)
-        self.assertEqual(self.watch, self.manager._wdm.get(1))
-        self.watch._watching = True
-        event = FakeFileEvent(256, None, os.path.join(self.path, 'test'))
-        self.watch.platform_watch._process_events(event)
-        self.assertEqual(0, len(events))
+        super(TestWatchManager, self).test_rm_present_wd()
 
     def test_rm_child_path(self):
         """Test the removal of a child path."""
-        events = []
-
-        def fake_processor(event):
-            """Memorize the processed events."""
-            events.append(event.pathname)
-
         self.patch(filesystem_notifications.reactor, 'callFromThread',
             lambda x, e: x(e))
-
-        self.watch._processor = fake_processor
-        child = os.path.join(self.path, 'child')
-        self.manager.rm_path(child)
-        self.assertEqual(self.watch, self.manager._wdm[1])
-        # assert that the correct event is ignored
-        self.watch.platform_watch.watching = True
-        event = FakeFileEvent(256, None, os.path.join('child', 'test'))
-        self.watch.platform_watch._process_events(event)
-        self.assertEqual(0, len(events))
-        # assert that other events are not ignored
-        event2 = FakeFileEvent(256, None, 'test')
-        self.watch.platform_watch._process_events(event2)
-        self.assertEqual(1, len(events))
-
-
-class TestWatchManagerAddWatches(BaseTwistedTestCase):
+        super(TestWatchManager, self).test_rm_child_path()
+
+
+class TestWatchManagerAddWatches(common_tests.TestWatchManagerAddWatches):
     """Test the watch manager."""
     timeout = 5
 
     def test_add_watch_twice(self):
         """Adding a watch twice succeeds when the watch is running."""
         self.patch(Watch, "start_watching", lambda self: None)
+        self.patch(Watch, "started", lambda self: True)
         manager = WatchManager(None)
         # no need to stop watching because start_watching is fake
 
@@ -936,7 +705,7 @@
         d2 = manager.add_watch(path, mask)
 
         self.assertTrue(d1.result, "Should not be called yet.")
-        self.assertFalse(d2.result, "Should not be called yet.")
+        self.assertTrue(d2, "Should not be called yet.")
 
 
 class FakeEvent(object):
@@ -953,88 +722,15 @@
         self.cookie = cookie
 
 
-class FakeLog(object):
-    """A fake log that is used by the general processor."""
-
-    def __init__(self):
-        """Create the fake."""
-        self.called_methods = []
-
-    def info(self, *args):
-        """Fake the info call."""
-        self.called_methods.append(('info', args))
-
-
-class FakeGeneralProcessor(object):
-    """Fake implementation of the general processor."""
-
-    def __init__(self):
-        """Create the fake."""
-        self.called_methods = []
-        self.paths_to_return = []
-        self.log = FakeLog()
-        self.share_id = None
-        self.ignore = False
-
-    def rm_from_mute_filter(self, event, paths):
-        """Fake rm_from_mute_filter."""
-        self.called_methods.append(('rm_from_mute_filter', event, paths))
-
-    def add_to_mute_filter(self, event, paths):
-        """Fake add_to_move_filter."""
-        self.called_methods.append(('add_to_mute_filter', event, paths))
-
-    def is_ignored(self, path):
-        """Fake is_ignored."""
-        self.called_methods.append(('is_ignored', path))
-        return self.ignore
-
-    def push_event(self, event):
-        """Fake push event."""
-        self.called_methods.append(('push_event', event))
-
-    def eq_push(self, event, path=None, path_to=None, path_from=None):
-        """Fake event to push event."""
-        self.called_methods.append(('eq_push', event, path, path_to,
-                                    path_from))
-
-    def get_paths_starting_with(self, fullpath, include_base=False):
-        """Fake get_paths_starting_with."""
-        self.called_methods.append(('get_paths_starting_with', fullpath,
-                                    include_base))
-        return self.paths_to_return
-
-    def get_path_share_id(self, path):
-        """Fake get_path_share_id."""
-        self.called_methods.append(('get_path_share_id', path))
-        return self.share_id
-
-    def rm_watch(self, path):
-        """Fake the remove watch."""
-        self.called_methods.append(('rm_watch', path))
-
-    def freeze_begin(self, path):
-        """Fake freeze_begin"""
-        self.called_methods.append(('freeze_begin', path))
-
-    def freeze_rollback(self):
-        """Fake rollback."""
-        self.called_methods.append(('freeze_rollback',))
-
-    def freeze_commit(self, path):
-        """Fake freeze commit."""
-        self.called_methods.append(('freeze_commit', path))
-
-
-class TestNotifyProcessor(BaseTwistedTestCase):
+class TestNotifyProcessor(common_tests.TestNotifyProcessor):
     """Test the notify processor."""
 
     @defer.inlineCallbacks
     def setUp(self):
-        """set up the diffeent tests."""
+        """set up the different tests."""
         yield super(TestNotifyProcessor, self).setUp()
         self.processor = notify_processor.NotifyProcessor(None)
-        self.general = FakeGeneralProcessor()
+        self.general = common_tests.FakeGeneralProcessor()
         self.processor.general_processor = self.general
 
     def test_rm_from_mute_filter(self):

=== modified file 'tests/platform/filesystem_notifications/test_fsevents_daemon.py'
--- tests/platform/filesystem_notifications/test_fsevents_daemon.py	2012-07-19 14:13:06 +0000
+++ tests/platform/filesystem_notifications/test_fsevents_daemon.py	2012-08-22 18:22:29 +0000
@@ -26,14 +26,14 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
-"""Tests for the fsevents daemon integration."""
+"""Tests for the fseventsd daemon integration."""
 
 import os
 
 from twisted.internet import defer, protocol
 
 from contrib.testing.testcase import BaseTwistedTestCase
-from ubuntuone.darwin import fsevents
+from ubuntuone import fseventsd
 from ubuntuone.devtools.testcases.txsocketserver import TidyUnixServer
 from ubuntuone.platform.filesystem_notifications.monitor.darwin import (
     fsevents_daemon,
@@ -272,7 +272,7 @@
         head, _ = os.path.split(destination_path)
         self.factory.watched_paths.append(head)
         event = FakeDaemonEvent()
-        event.event_type = fsevents.FSE_RENAME
+        event.event_type = fseventsd.FSE_RENAME
         event.event_paths.extend([source_path, destination_path])
         converted_events = self.factory.convert_in_pyinotify_event(event)
         self.assertEqual(1, len(converted_events))
@@ -289,7 +289,7 @@
         head, _ = os.path.split(source_path)
         self.factory.watched_paths.append(head)
         event = FakeDaemonEvent()
-        event.event_type = fsevents.FSE_RENAME
+        event.event_type = fseventsd.FSE_RENAME
         event.event_paths.extend([source_path, destination_path])
         converted_events = self.factory.convert_in_pyinotify_event(event)
         self.assertEqual(1, len(converted_events))
@@ -306,7 +306,7 @@
         head, _ = os.path.split(source_path)
         self.factory.watched_paths.append(head)
         event = FakeDaemonEvent()
-        event.event_type = fsevents.FSE_RENAME
+        event.event_type = fseventsd.FSE_RENAME
         event.event_paths.extend([source_path, destination_path])
         converted_events = self.factory.convert_in_pyinotify_event(event)
         self.assertEqual(2, len(converted_events))
@@ -337,7 +337,7 @@
         """Test processing the drop of the events."""
         func_called = []
         event = FakeDaemonEvent()
-        event.event_type = fsevents.FSE_EVENTS_DROPPED
+        event.event_type = fseventsd.FSE_EVENTS_DROPPED
 
         def fake_events_dropped():
             """A fake events dropped implementation."""
@@ -354,7 +354,7 @@
         self.factory.ignored_paths.append(head)
         event = FakeDaemonEvent()
         event.event_paths.append(event_path)
-        event.event_type = fsevents.FSE_CREATE_FILE
+        event.event_type = fseventsd.FSE_CREATE_FILE
         self.factory.process_event(event)
         self.assertEqual(0, len(self.processor.processed_events))
 
@@ -365,7 +365,7 @@
         self.factory.watched_paths.append(head)
         event = FakeDaemonEvent()
         event.event_paths.append(event_path)
-        event.event_type = fsevents.FSE_CREATE_FILE
+        event.event_type = fseventsd.FSE_CREATE_FILE
         self.factory.process_event(event)
         self.assertEqual(1, len(self.processor.processed_events))
         self.assertEqual(event_path,

=== added file 'tests/platform/filesystem_notifications/test_windows.py'
--- tests/platform/filesystem_notifications/test_windows.py	1970-01-01 00:00:00 +0000
+++ tests/platform/filesystem_notifications/test_windows.py	2012-08-22 18:22:29 +0000
@@ -0,0 +1,344 @@
+#
+# Authors: Manuel de la Pena <[e-mail]>
+#          Alejandro J. Cura <[e-mail]>
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Test the filesystem notifications on windows."""
+
+import os
+
+from twisted.internet import defer
+from win32file import FILE_NOTIFY_INFORMATION
+
+from ubuntuone.platform.filesystem_notifications.monitor import (
+    common,
+    windows as filesystem_notifications,
+)
+from ubuntuone.platform.filesystem_notifications.monitor.common import (
+    FilesystemMonitor,
+    Watch,
+    WatchManager,
+)
+from ubuntuone.platform.filesystem_notifications.monitor.windows import (
+    FILE_NOTIFY_CHANGE_FILE_NAME,
+    FILE_NOTIFY_CHANGE_DIR_NAME,
+    FILE_NOTIFY_CHANGE_ATTRIBUTES,
+    FILE_NOTIFY_CHANGE_SIZE,
+    FILE_NOTIFY_CHANGE_LAST_WRITE,
+    FILE_NOTIFY_CHANGE_SECURITY,
+    FILE_NOTIFY_CHANGE_LAST_ACCESS,
+)
+from tests.platform.filesystem_notifications import common as common_tests
+
+
+class FakeEventsProcessor(object):
+
+    """Handle fake events creation and processing."""
+
+    def create_fake_event(self, filename):
+        """Create a fake file event."""
+        return (1, filename)
+
+    def custom_process_events(self, watch, events):
+        """Adapt to each platform way to process events."""
+        watch.platform_watch._process_events(events)
+
+
+class TestWatch(common_tests.TestWatch):
+    """Test the watch so that it returns the same events as pyinotify."""
+
+    timeout = 5
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(TestWatch, self).setUp()
+        self.path = u'\\\\?\\C:\\path'  # a valid windows path
+        self.common_path = u'C:\\path'
+        self.invalid_path = u'\\\\?\\C:\\path\\to\\no\\dir'
+        self.mask = FILE_NOTIFY_CHANGE_FILE_NAME | \
+            FILE_NOTIFY_CHANGE_DIR_NAME | \
+            FILE_NOTIFY_CHANGE_ATTRIBUTES | \
+            FILE_NOTIFY_CHANGE_SIZE | \
+            FILE_NOTIFY_CHANGE_LAST_WRITE | \
+            FILE_NOTIFY_CHANGE_SECURITY | \
+            FILE_NOTIFY_CHANGE_LAST_ACCESS
+        self.fake_events_processor = FakeEventsProcessor()
+
+        def file_notify_information_wrapper(buf, data):
+            """Wrapper that gets the events and adds them to the list."""
+            events = FILE_NOTIFY_INFORMATION(buf, data)
+            # we want to append the list because that is what will be logged.
+            # If we use extend we wont have the same logging because it will
+            # group all events in a single lists which is not what the COM API
+            # does.
+            str_events = [
+                (common.ACTIONS_NAMES[action], path) for action, path in
+                 events]
+            self.raw_events.append(str_events)
+            return events
+
+        self.patch(filesystem_notifications, 'FILE_NOTIFY_INFORMATION',
+                   file_notify_information_wrapper)
+
+    @defer.inlineCallbacks
+    def test_file_write(self):
+        """Test that the correct event is raised when a file is written."""
+        file_name = os.path.join(self.basedir, 'test_file_write')
+        # create the file before recording
+        fd = open(file_name, 'w')
+        # clean behind us by removing the file
+        self.addCleanup(os.remove, file_name)
+
+        def write_file():
+            """Action for the test."""
+            fd.write('test')
+            fd.close()
+
+        events = yield self._perform_operations(self.basedir, self.mask,
+                                                write_file, 1)
+        event = events[0]
+        self.assertFalse(event.dir)
+        self.assertEqual(0x2, event.mask)
+        self.assertEqual('IN_MODIFY', event.maskname)
+        self.assertEqual(os.path.split(file_name)[1], event.name)
+        self.assertEqual('.', event.path)
+        self.assertEqual(os.path.join(self.basedir, file_name), event.pathname)
+        self.assertEqual(0, event.wd)
+
+    @defer.inlineCallbacks
+    def test_call_deferred_already_called(self):
+        """Test that the function is not called."""
+        method_args = []
+
+        def fake_call(*args, **kwargs):
+            """Execute the call."""
+            method_args.append((args, kwargs),)
+
+        watch = Watch(1, self.path, None)
+        yield watch.platform_watch._watch_started_deferred.callback(True)
+        watch.platform_watch._call_deferred(fake_call, None)
+        self.assertEqual(0, len(method_args))
+
+    def test_call_deferred_not_called(self):
+        """Test that is indeed called."""
+        method_args = []
+
+        def fake_call(*args, **kwargs):
+            """Execute the call."""
+            method_args.append((args, kwargs),)
+
+        watch = Watch(1, self.path, None)
+        watch.platform_watch._call_deferred(fake_call, None)
+        self.assertEqual(1, len(method_args))
+
+    def test_started_property(self):
+        """Test that the started property returns the started deferred."""
+        watch = Watch(1, self.path, None)
+        self.assertEqual(watch.started,
+            watch.platform_watch._watch_started_deferred)
+
+    def test_stopped_property(self):
+        """Test that the stopped property returns the stopped deferred."""
+        watch = Watch(1, self.path, None)
+        self.assertEqual(watch.stopped,
+            watch.platform_watch._watch_stopped_deferred)
+
+    @defer.inlineCallbacks
+    def test_start_watching_fails_early_in_thread(self):
+        """An early failure inside the thread should errback the deferred."""
+        test_path = self.mktemp("test_directory")
+        self.patch(filesystem_notifications, "CreateFileW", self.random_error)
+        watch = Watch(1, test_path, None)
+        d = watch.start_watching()
+        yield self.assertFailure(d, common_tests.FakeException)
+
+    @defer.inlineCallbacks
+    def test_start_watching_fails_late_in_thread(self):
+        """A late failure inside the thread should errback the deferred."""
+        test_path = self.mktemp("test_directory")
+        self.patch(filesystem_notifications, "ReadDirectoryChangesW",
+                   self.random_error)
+        watch = Watch(1, test_path, None)
+        d = watch.start_watching()
+        yield self.assertFailure(d, common_tests.FakeException)
+
+    @defer.inlineCallbacks
+    def test_close_handle_is_called_on_error(self):
+        """CloseHandle is called when there's an error in the watch thread."""
+        test_path = self.mktemp("test_directory")
+        close_called = []
+        self.patch(filesystem_notifications, "CreateFileW", lambda *_: None)
+        self.patch(filesystem_notifications, "CloseHandle",
+                   close_called.append)
+        self.patch(filesystem_notifications, "ReadDirectoryChangesW",
+                   self.random_error)
+        watch = Watch(1, test_path, self.mask)
+        d = watch.start_watching()
+        yield self.assertFailure(d, common_tests.FakeException)
+        self.assertEqual(len(close_called), 1)
+        yield watch.stop_watching()
+
+    @defer.inlineCallbacks
+    def test_stop_watching_fired_when_watch_thread_finishes(self):
+        """The deferred returned is fired when the watch thread finishes."""
+        test_path = self.mktemp("another_test_directory")
+        watch = Watch(1, test_path, self.mask)
+        yield watch.start_watching()
+        self.assertNotEqual(watch.platform_watch._watch_handle, None)
+        yield watch.stop_watching()
+        self.assertEqual(watch.platform_watch._watch_handle, None)
+
+
+class TestWatchManager(common_tests.TestWatchManager):
+    """Test the watch manager."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set each of the tests."""
+        yield super(TestWatchManager, self).setUp()
+        self.parent_path = u'\\\\?\\C:\\'  # a valid windows path
+        self.path = self.parent_path + u'path'
+        self.watch = Watch(1, self.path, None)
+        self.manager._wdm = {1: self.watch}
+        self.fake_events_processor = FakeEventsProcessor()
+
+    def test_add_single_watch(self):
+        """Test the addition of a new single watch."""
+        self.was_called = False
+
+        def fake_start_watching(*args):
+            """Fake start watch."""
+            self.was_called = True
+
+        self.patch(Watch, "start_watching", fake_start_watching)
+        self.manager._wdm = {}
+
+        mask = 'bit_mask'
+        self.manager.add_watch(self.path, mask)
+        self.assertEqual(1, len(self.manager._wdm))
+        self.assertTrue(self.was_called, 'The watch start was not called.')
+        self.assertEqual(self.path + os.path.sep, self.manager._wdm[0].path)
+        self.assertEqual(filesystem_notifications.FILESYSTEM_MONITOR_MASK,
+            self.manager._wdm[0].platform_watch._mask)
+
+    @defer.inlineCallbacks
+    def test_stop_multiple(self):
+        """Test that stop is fired when *all* watches have stopped."""
+
+        def fake_stop_watching(watch):
+            """Another fake stop watch."""
+            return watch.stopped
+
+        self.patch(Watch, "stop_watching", fake_stop_watching)
+        second_path = self.parent_path + u"second_path"
+        second_watch = Watch(2, second_path, None)
+        self.manager._wdm[2] = second_watch
+        d = self.manager.stop()
+        self.assertFalse(d.called, "Not fired before all watches end")
+        self.watch.stopped.callback(None)
+        self.assertFalse(d.called, "Not fired before all watches end")
+        second_watch.stopped.callback(None)
+        yield d
+        self.assertTrue(d.called, "Fired after the watches ended")
+
+
+class TestWatchManagerAddWatches(common_tests.TestWatchManagerAddWatches):
+    """Test the watch manager."""
+    timeout = 5
+
+    def test_add_watch_twice(self):
+        """Adding a watch twice succeeds when the watch is running."""
+        self.patch(Watch, "start_watching", lambda self: self.started)
+        manager = WatchManager(None)
+        # no need to stop watching because start_watching is fake
+
+        path = u'\\\\?\\C:\\test'  # a valid windows path
+        mask = 'fake bit mask'
+        d1 = manager.add_watch(path, mask)
+        d2 = manager.add_watch(path, mask)
+
+        self.assertFalse(d1.called, "Should not be called yet.")
+        self.assertFalse(d2.called, "Should not be called yet.")
+
+        manager._wdm.values()[0].started.callback(True)
+
+        self.assertTrue(d1.called, "Should already be called.")
+        self.assertTrue(d2.called, "Should already be called.")
+
+
+class TestNotifyProcessor(common_tests.TestNotifyProcessor):
+    """Test the notify processor."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """set up the diffeent tests."""
+        yield super(TestNotifyProcessor, self).setUp()
+
+
+class FilesystemMonitorTestCase(common_tests.FilesystemMonitorTestCase):
+    """Tests for the FilesystemMonitor."""
+    timeout = 5
+
+    def test_add_watch_twice(self):
+        """Check the deferred returned by a second add_watch."""
+        self.patch(Watch, "start_watching", lambda self: self.started)
+        monitor = FilesystemMonitor(None, None)
+        # no need to stop watching because start_watching is fake
+
+        parent_path = 'C:\\test'  # a valid windows path in utf-8 bytes
+        child_path = parent_path + "\\child"
+        d1 = monitor.add_watch(parent_path)
+        d2 = monitor.add_watch(child_path)
+
+        self.assertFalse(d1.called, "Should not be called yet.")
+        self.assertFalse(d2.called, "Should not be called yet.")
+
+        monitor._watch_manager._wdm.values()[0].started.callback(True)
+
+        self.assertTrue(d1.called, "Should already be called.")
+        self.assertTrue(d2.called, "Should already be called.")
+
+    @defer.inlineCallbacks
+    def test_add_watches_to_udf_ancestors(self):
+        """Test that the ancestor watches are not added."""
+
+        class FakeVolume(object):
+            """A fake UDF."""
+
+            def __init__(self, ancestors):
+                """Create a new instance."""
+                self.ancestors = ancestors
+
+        ancestors = ['~', '~\\Pictures', '~\\Pictures\\Home', ]
+        volume = FakeVolume(ancestors)
+        monitor = FilesystemMonitor(None, None)
+        added = yield monitor.add_watches_to_udf_ancestors(volume)
+        self.assertTrue(added, 'We should always return true.')
+        # lets ensure that we never added the watches
+        self.assertEqual(0, len(monitor._watch_manager._wdm.values()),
+                         'No watches should have been added.')

=== modified file 'tests/platform/ipc/test_external_interface.py'
--- tests/platform/ipc/test_external_interface.py	2012-04-30 14:24:55 +0000
+++ tests/platform/ipc/test_external_interface.py	2012-08-22 18:22:29 +0000
@@ -40,6 +40,10 @@
     StatusTestCase,
     SyncDaemonTestCase,
 )
+from ubuntuone.syncdaemon import (
+    RECENT_TRANSFERS,
+    UPLOADING,
+)
 
 STR = 'something'
 STR_STR_DICT = {'foo': 'bar'}
@@ -132,6 +136,16 @@
         self.assert_remote_method('waiting_metadata',
             in_signature=None, out_signature='a(sa{ss})')
 
+    @defer.inlineCallbacks
+    def test_sync_menu(self):
+        """Test sync_menu."""
+        result = {RECENT_TRANSFERS: [], UPLOADING: []}
+        method = 'sync_menu'
+        yield self.assert_method_called(self.service.status,
+                                        method, result)
+        self.assert_remote_method(method,
+            in_signature=None, out_signature='a{sv}')
+
 
 class EventsTests(EventsTestCase):
     """Basic tests for the Events exposed object."""

=== modified file 'tests/platform/test_tools.py'
--- tests/platform/test_tools.py	2012-05-30 15:35:49 +0000
+++ tests/platform/test_tools.py	2012-08-22 18:22:29 +0000
@@ -36,12 +36,15 @@
 from ubuntuone.devtools.handlers import MementoHandler
 
 from contrib.testing.testcase import FakeCommand, skipIfOS
+
 from ubuntuone.syncdaemon import (
     action_queue,
     event_queue,
     interaction_interfaces,
     states,
     volume_manager,
+    RECENT_TRANSFERS,
+    UPLOADING,
 )
 from ubuntuone.platform import tools
 from tests.platform import IPCTestCase
@@ -243,6 +246,13 @@
         self.assertEqual('share_id', result['volume_id'])
         self.assertEqual(False, self.main.vm.shares['share_id'].accepted)
 
+    @defer.inlineCallbacks
+    def test_sync_menu(self):
+        """Test accept_share method."""
+        result = yield self.tool.sync_menu()
+        self.assertIn(RECENT_TRANSFERS, result)
+        self.assertIn(UPLOADING, result)
+
 
 class TestWaitForSignals(TestToolsBase):
     """Test case for the wait_for_signals method from SyncDaemonTool."""

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2012-04-09 20:07:05 +0000
+++ tests/status/test_aggregator.py	2012-08-22 18:22:29 +0000
@@ -42,7 +42,11 @@
 from ubuntuone.status import aggregator
 from ubuntuone.status.notification import AbstractNotification
 from ubuntuone.status.messaging import AbstractMessaging
-from ubuntuone.syncdaemon import status_listener
+from ubuntuone.syncdaemon import (
+    status_listener,
+    RECENT_TRANSFERS,
+    UPLOADING,
+)
 from ubuntuone.syncdaemon.volume_manager import Share, UDF, Root
 
 FILENAME = 'example.txt'
@@ -706,6 +710,8 @@
         self.share_id = path
         self.node_id = path
         self.deflated_size = 10000
+        self.size = 0
+        self.n_bytes_written = 0
 
 
 class FakeVolumeManager(object):
@@ -733,6 +739,7 @@
         self.files_uploading = []
         self.files_downloading = []
         self.progress_events = []
+        self.recent_transfers = aggregator.deque(maxlen=10)
 
     def queue_done(self):
         """The queue completed all operations."""
@@ -762,6 +769,7 @@
         """An upload just finished."""
         if command in self.files_uploading:
             self.files_uploading.remove(command)
+        self.recent_transfers.append(command.path)
         self.queued_commands.discard(command)
 
     def progress_made(self, share_id, node_id, n_bytes, deflated_size):
@@ -796,6 +804,70 @@
                                                        self.fakevm,
                                                        self.status_frontend)
 
+    def test_recent_transfers(self):
+        """Check that it generates a tuple with the recent transfers."""
+        self.patch(status_listener.action_queue, "Upload", FakeCommand)
+        fake_command = FakeCommand('path1')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        fake_command = FakeCommand('path2')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        fake_command = FakeCommand('path3')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        transfers = self.status_frontend.recent_transfers()
+        expected = ['path1', 'path2', 'path3']
+        self.assertEqual(transfers, expected)
+
+        menu_data = self.listener.menu_data()
+        self.assertEqual(menu_data,
+            {UPLOADING: [], RECENT_TRANSFERS: expected})
+
+    def test_file_uploading(self):
+        """Check that it returns a list with the path, size, and progress."""
+        fc = FakeCommand(path='testfile.txt')
+        fc.size = 200
+        self.status_frontend.upload_started(fc)
+        uploading = self.status_frontend.files_uploading()
+        expected = [('testfile.txt', 200, 0)]
+        self.assertEqual(uploading, expected)
+        menu_data = self.listener.menu_data()
+        self.assertEqual(menu_data,
+            {UPLOADING: expected, RECENT_TRANSFERS: []})
+
+        fc.size = 1000
+        fc.n_bytes_written = 200
+        fc2 = FakeCommand(path='testfile2.txt')
+        fc2.size = 2000
+        fc2.n_bytes_written = 450
+        self.status_frontend.upload_started(fc2)
+        uploading = self.status_frontend.files_uploading()
+        expected = [('testfile.txt', 1000, 200), ('testfile2.txt', 2000, 450)]
+        self.assertEqual(uploading, expected)
+
+        menu_data = self.listener.menu_data()
+        self.assertEqual(menu_data,
+            {UPLOADING: expected, RECENT_TRANSFERS: []})
+
+    def test_menu_data_full_response(self):
+        """Check that listener.menu_data returns both uploading and recent."""
+        self.patch(status_listener.action_queue, "Upload", FakeCommand)
+        fake_command = FakeCommand('path1')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        fc = FakeCommand(path='testfile.txt')
+        fc.size = 1000
+        fc.n_bytes_written = 200
+        self.status_frontend.upload_started(fc)
+        uploading = self.status_frontend.files_uploading()
+        transfers = self.status_frontend.recent_transfers()
+        expected = {UPLOADING: [('testfile.txt', 1000, 200)],
+            RECENT_TRANSFERS: ['path1']}
+
+        self.assertEqual(
+            {UPLOADING: uploading, RECENT_TRANSFERS: transfers}, expected)
+
     def test_file_published(self):
         """A file published event is processed."""
         share_id = "fake share id"
@@ -1308,6 +1380,15 @@
         self.assertEqual(
             {(fc.share_id, fc.node_id): (fc.deflated_size)},
             self.aggregator.progress)
+        self.assertEqual(len(self.aggregator.recent_transfers), 1)
+
+    def test_max_recent_files(self):
+        """Check that the queue doesn't exceed the 5 items."""
+        for i in range(15):
+            fc = FakeCommand()
+            self.status_frontend.upload_started(fc)
+            self.status_frontend.upload_finished(fc)
+        self.assertEqual(len(self.aggregator.recent_transfers), 5)
 
     def test_progress_made(self):
         """Progress on up and downloads is tracked."""

=== modified file 'tests/syncdaemon/test_fsm.py'
--- tests/syncdaemon/test_fsm.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_fsm.py	2012-08-22 18:22:29 +0000
@@ -1626,6 +1626,33 @@
         mdobj = self.fsm.get_by_mdid(mdid)
         self.assertEqual(mdobj.stat, stat_path(path))
 
+    def test_commit_partial_pushes_event(self):
+        """Test that the right event is pushed after the commit."""
+        listener = Listener()
+        self.eq.subscribe(listener)
+
+        path = os.path.join(self.share.path, "thisfile")
+        open_file(path, "w").close()
+        mdobj = self.create_node("thisfile")
+        mdid = mdobj.mdid
+        oldstat = stat_path(path)
+        self.assertEqual(mdobj.stat, oldstat)
+
+        # create a partial
+        self.fsm.create_partial(mdobj.node_id, mdobj.share_id)
+        fh = self.fsm.get_partial_for_writing(mdobj.node_id, mdobj.share_id)
+        fh.write("foobar")
+        fh.close()
+        mdobj = self.fsm.get_by_mdid(mdid)
+        self.assertEqual(mdobj.stat, oldstat)
+
+        # commit the partial
+        self.fsm.commit_partial(mdobj.node_id, mdobj.share_id, "localhash")
+        mdobj = self.fsm.get_by_mdid(mdid)
+
+        kwargs = dict(share_id=mdobj.share_id, node_id=mdobj.node_id)
+        self.assertTrue(("FSM_PARTIAL_COMMITED", kwargs) in listener.events)
+
     def test_move(self):
         """Test that move refreshes stat."""
         path1 = os.path.join(self.share.path, "thisfile1")

=== modified file 'tests/syncdaemon/test_interaction_interfaces.py'
--- tests/syncdaemon/test_interaction_interfaces.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_interaction_interfaces.py	2012-08-22 18:22:29 +0000
@@ -1226,18 +1226,19 @@
         self.addCleanup(self.main.event_q.unsubscribe, self.sd_obj)
 
 
-class DownloadTestCase(SyncdaemonEventListenerTestCase):
-    """Test the Download events in SyncdaemonEventListener."""
+class UploadTestCase(SyncdaemonEventListenerTestCase):
+    """Test the Upload events in SyncdaemonEventListener."""
 
     add_fsm_key = True
-    direction = 'Download'
-    bytes_key = 'n_bytes_read'
-    hash_kwarg = 'server_hash'
-    extra_finished_args = {}
+    direction = 'Upload'
+    bytes_key = 'n_bytes_written'
+    hash_kwarg = 'hash'
+    extra_finished_args = dict(new_generation='new_generation', hash='')
+    finished_event = 'AQ_UPLOAD_FINISHED'
 
     @defer.inlineCallbacks
     def setUp(self):
-        yield super(DownloadTestCase, self).setUp()
+        yield super(UploadTestCase, self).setUp()
         self.deferred = None
         self.signal_name = None
         if self.add_fsm_key:
@@ -1304,7 +1305,7 @@
         return self.deferred
 
     def test_handle_finished(self):
-        """Test the handle_AQ_<direction>_FINISHED method."""
+        """Test the handle_<finished_event> method."""
         self.signal_name = self.direction + 'Finished'
         self.deferred = defer.Deferred()
 
@@ -1320,10 +1321,9 @@
             self.patch(self.sd_obj.interface.status, 'SignalError',
                        self.error_handler)
 
-        kwargs = {'share_id': '', 'node_id': 'node_id', self.hash_kwarg: ''}
+        kwargs = {'share_id': '', 'node_id': 'node_id'}
         kwargs.update(self.extra_finished_args)
-        self.main.event_q.push('AQ_%s_FINISHED' % self.direction.upper(),
-                               **kwargs)
+        self.main.event_q.push(self.finished_event, **kwargs)
         return self.deferred
 
     def test_handle_event_error(self):
@@ -1350,21 +1350,29 @@
         return self.deferred
 
 
+class DownloadTestCase(UploadTestCase):
+    """Test the Download events in SyncdaemonEventListener."""
+
+    direction = 'Download'
+    bytes_key = 'n_bytes_read'
+    hash_kwarg = 'server_hash'
+    extra_finished_args = {}
+    finished_event = 'FSM_PARTIAL_COMMITED'
+
+    # The download is special, because we don't want to throw the ipc signal on
+    # AQ_DOWNLOAD_FINISHED but instead we should wait for FSM_PARTIAL_COMMITED
+
+    def test_ignore_pre_partial_commit_event(self):
+        """The AQ_DOWNLOAD_FINISHED signal is ignored."""
+        self.assertNotIn("handle_AQ_DOWNLOAD_FINISHED", vars(self.sd_class))
+
+
 class DownloadNoKeyTestCase(DownloadTestCase):
     """Test the Download events when there is a fsm KeyError."""
 
     add_fsm_key = False
 
 
-class UploadTestCase(DownloadTestCase):
-    """Test the Upload events in SyncdaemonEventListener."""
-
-    direction = 'Upload'
-    bytes_key = 'n_bytes_written'
-    hash_kwarg = 'hash'
-    extra_finished_args = dict(new_generation='new_generation')
-
-
 class UploadNoKeyTestCase(UploadTestCase):
     """Test the Upload events when there is a fsm KeyError."""
 

=== modified file 'tests/syncdaemon/test_vm.py'
--- tests/syncdaemon/test_vm.py	2012-04-09 20:07:05 +0000
+++ tests/syncdaemon/test_vm.py	2012-08-22 18:22:29 +0000
@@ -2752,7 +2752,7 @@
 
         result, msg = self.vm.validate_path_for_folder(folder_path)
         self.assertTrue(result)
-        self.assertIs(msg, "", 
+        self.assertIs(msg, "",
             '%r must be a valid path for creating a folder.' % folder_path)
 
     def test_validate_UDF_path_if_folder_shares_a_prefix_with_an_udf(self):
@@ -2769,7 +2769,7 @@
 
         result, msg = self.vm.validate_path_for_folder(tricky_path)
         self.assertTrue(result)
-        self.assertIs(msg, "", 
+        self.assertIs(msg, "",
             '%r must be a valid path for creating a folder.' % tricky_path)
 
     def test_validate_UDF_path_not_valid_if_outside_home(self):
@@ -2818,6 +2818,17 @@
         self.assertIsNot(msg, "",
             '%r must be an invalid path for creating a folder.' % udf_parent)
 
+    def test_not_valid_if_folder_is_file(self):
+        """A link path is not valid."""
+        self.patch(volume_manager.os.path, 'isdir', lambda p: False)
+        self.patch(volume_manager, 'path_exists', lambda p: True)
+        path_link = os.path.join(self.home_dir, 'Test Me')
+
+        result, msg = self.vm.validate_path_for_folder(path_link)
+        self.assertFalse(result)
+        self.assertIsNot(msg, "",
+            '%r must be an invalid path for creating a folder.' % path_link)
+
     def test_not_valid_if_folder_is_link(self):
         """A link path is not valid."""
         self.patch(volume_manager, 'is_link', lambda p: True)

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-07-18 15:18:04 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-08-22 18:22:29 +0000
@@ -42,11 +42,13 @@
 if sys.platform == 'win32':
     from ubuntuone.platform.filesystem_notifications.monitor import (
         common,
+        windows,
     )
 
     FILEMONITOR_IDS = {
         DEFAULT_MONITOR: common.FilesystemMonitor,
     }
+    ACTIONS = windows.ACTIONS
 
 elif sys.platform == 'darwin':
     from ubuntuone.platform.filesystem_notifications.monitor import darwin
@@ -58,6 +60,7 @@
         DEFAULT_MONITOR: common.FilesystemMonitor,
         'daemon': darwin.fsevents_daemon.FilesystemMonitor,
     }
+    ACTIONS = darwin.fsevents_client.ACTIONS
 else:
     from ubuntuone.platform.filesystem_notifications.monitor import (
         linux,

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/common.py'
--- ubuntuone/platform/filesystem_notifications/monitor/common.py	2012-07-18 09:05:26 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/common.py	2012-08-22 18:22:29 +0000
@@ -65,6 +65,7 @@
 else:
     raise ImportError('Not supported platform')
 
+
 # a map between the few events that we have on common platforms and those
 # found in pyinotify
 ACTIONS = source.ACTIONS

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-07-19 14:13:06 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-08-22 18:22:29 +0000
@@ -25,7 +25,7 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
-"""Filesystem notifications based on the fsevents daemon.."""
+"""Filesystem notifications based on the fseventsd daemon.."""
 
 import logging
 import os
@@ -42,7 +42,7 @@
 )
 
 from ubuntuone import logger
-from ubuntuone.darwin import fsevents
+from ubuntuone import fseventsd
 from ubuntuone.platform.filesystem_notifications.notify_processor import (
     NotifyProcessor,
 )
@@ -61,24 +61,24 @@
 
 TRACE = logger.TRACE
 
-# map the fsevents actions to those from pyinotify
+# map the fseventsd actions to those from pyinotify
 DARWIN_ACTIONS = {
-    fsevents.FSE_CREATE_FILE: IN_CREATE,
-    fsevents.FSE_DELETE: IN_DELETE,
-    fsevents.FSE_STAT_CHANGED: IN_MODIFY,
-    fsevents.FSE_CONTENT_MODIFIED: IN_MODIFY,
-    fsevents.FSE_CREATE_DIR: IN_CREATE,
+    fseventsd.FSE_CREATE_FILE: IN_CREATE,
+    fseventsd.FSE_DELETE: IN_DELETE,
+    fseventsd.FSE_STAT_CHANGED: IN_MODIFY,
+    fseventsd.FSE_CONTENT_MODIFIED: IN_MODIFY,
+    fseventsd.FSE_CREATE_DIR: IN_CREATE,
 }
 
 # list of those events from which we do not care
 DARWIN_IGNORED_ACTIONS = (
-    fsevents.FSE_UNKNOWN,
-    fsevents.FSE_INVALID,
-    fsevents.FSE_EXCHANGE,
-    fsevents.FSE_FINDER_INFO_CHANGED,
-    fsevents.FSE_CHOWN,
-    fsevents.FSE_XATTR_MODIFIED,
-    fsevents.FSE_XATTR_REMOVED,
+    fseventsd.FSE_UNKNOWN,
+    fseventsd.FSE_INVALID,
+    fseventsd.FSE_EXCHANGE,
+    fseventsd.FSE_FINDER_INFO_CHANGED,
+    fseventsd.FSE_CHOWN,
+    fseventsd.FSE_XATTR_MODIFIED,
+    fseventsd.FSE_XATTR_REMOVED,
 )
 
 # translates quickly the event and it's is_dir state to our standard events
@@ -95,7 +95,7 @@
     IN_MOVED_TO: 'FS_FILE_CREATE',
     IN_MOVED_TO | IN_ISDIR: 'FS_DIR_CREATE'}
 
-# TODO: This should be in fsevents to be imported!
+# TODO: This should be in fseventsd to be imported!
 # Path to the socket used by the daemon
 DAEMON_SOCKET = '/var/run/ubuntuone_fsevents_daemon'
 
@@ -134,14 +134,14 @@
     return unicodedata.normalize('NFC', path).encode('utf-8')
 
 
-class PyInotifyEventsFactory(fsevents.FsEventsFactory):
+class PyInotifyEventsFactory(fseventsd.FsEventsFactory):
     """Factory that process events and converts them in pyinotify ones."""
 
     def __init__(self, processor,
             ignored_events=DARWIN_IGNORED_ACTIONS):
         """Create a new instance."""
         # old style class
-        fsevents.FsEventsFactory.__init__(self)
+        fseventsd.FsEventsFactory.__init__(self)
         self._processor = processor
         self._ignored_events = ignored_events
         self.watched_paths = []
@@ -215,7 +215,7 @@
         """Get an event from the daemon and convert it in a pyinotify one."""
         # the rename is a special type of event because it has to be either
         # converted is a pair of events or in a single one (CREATE or DELETE)
-        if event.event_type == fsevents.FSE_RENAME:
+        if event.event_type == fseventsd.FSE_RENAME:
             is_create = self.is_create(event)
             if is_create or self.is_delete(event):
                 mask = IN_CREATE if is_create else IN_DELETE
@@ -278,7 +278,7 @@
         if event.event_type in self._ignored_events:
             # Do nothing because sd does not care about such info
             return
-        if event.event_type == fsevents.FSE_EVENTS_DROPPED:
+        if event.event_type == fseventsd.FSE_EVENTS_DROPPED:
             # this should not be very common but we have to deal with it
             return self.events_dropper()
         events = self.convert_in_pyinotify_event(event)

=== modified file 'ubuntuone/platform/ipc/ipc_client.py'
--- ubuntuone/platform/ipc/ipc_client.py	2012-05-22 14:28:56 +0000
+++ ubuntuone/platform/ipc/ipc_client.py	2012-08-22 18:22:29 +0000
@@ -197,6 +197,22 @@
     def current_uploads(self):
         """Return a list of files with a upload in progress."""
 
+    @remote
+    def sync_menu(self):
+        """
+        This method returns a dictionary, with the following keys and values:
+
+        Key: 'recent-transfers'
+        Value: a list of strings (paths), each being the name of a file that
+               was recently transferred.
+
+        Key: 'uploading'
+        Value: a list of tuples, with each tuple having the following items:
+         * str: the path of a file that's currently being uploaded
+         * int: size of the file
+         * int: bytes written
+        """
+
     @signal
     def on_content_queue_changed(self):
         """Emit ContentQueueChanged."""
@@ -234,7 +250,7 @@
         """Emit UploadFileProgress."""
 
     @signal
-    def on_upload_finished(self, upload, **info):
+    def on_upload_finished(self, upload, *info):
         """Emit UploadFinished."""
 
     @signal

=== modified file 'ubuntuone/platform/ipc/linux.py'
--- ubuntuone/platform/ipc/linux.py	2012-05-22 14:07:55 +0000
+++ ubuntuone/platform/ipc/linux.py	2012-08-22 18:22:29 +0000
@@ -38,6 +38,10 @@
 from xml.etree import ElementTree
 
 from ubuntuone.platform.launcher import UbuntuOneLauncher
+from ubuntuone.syncdaemon import (
+    RECENT_TRANSFERS,
+    UPLOADING,
+)
 
 # Disable the "Invalid Name" check here, as we have lots of DBus style names
 # pylint: disable-msg=C0103
@@ -173,6 +177,35 @@
         warnings.warn('Use "waiting" method instead.', DeprecationWarning)
         return self.service.status.waiting_content()
 
+    @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='a{sv}')
+    def sync_menu(self):
+        """
+        This method returns a dictionary, with the following keys and values:
+
+        Key: 'recent-transfers'
+        Value: a list of strings (paths), each being the name of a file that
+               was recently transferred.
+
+        Key: 'uploading'
+        Value: a list of tuples, with each tuple having the following items:
+         * str: the path of a file that's currently being uploaded
+         * int: size of the file
+         * int: bytes written
+        """
+        data = self.service.status.sync_menu()
+        uploading = data[UPLOADING]
+        transfers = data[RECENT_TRANSFERS]
+        upload_data = dbus.Array(signature="(sii)")
+        transfer_data = dbus.Array(signature="s")
+        for up in uploading:
+            upload_data.append(dbus.Struct(up, signature="sii"))
+        for transfer in transfers:
+            transfer_data.append(transfer)
+        result = dbus.Dictionary(signature="sv")
+        result[UPLOADING] = upload_data
+        result[RECENT_TRANSFERS] = transfer_data
+        return result
+
     @dbus.service.signal(DBUS_IFACE_STATUS_NAME)
     def DownloadStarted(self, path):
         """Fire a signal to notify that a download has started."""

=== modified file 'ubuntuone/platform/ipc/perspective_broker.py'
--- ubuntuone/platform/ipc/perspective_broker.py	2012-07-13 16:06:27 +0000
+++ ubuntuone/platform/ipc/perspective_broker.py	2012-08-22 18:22:29 +0000
@@ -231,6 +231,7 @@
         'waiting',
         'waiting_metadata',
         'waiting_content',
+        'sync_menu',
     ]
 
     signal_mapping = {
@@ -291,6 +292,10 @@
         warnings.warn('Use "waiting" method instead.', DeprecationWarning)
         return self.service.status.waiting_content()
 
+    def sync_menu(self):
+        """Return the info necessary to construct the menu."""
+        return self.service.status.sync_menu()
+
     @signal
     def DownloadStarted(self, path):
         """Fire a signal to notify that a download has started."""
@@ -300,7 +305,7 @@
         """Fire a signal to notify about a download progress."""
 
     @signal
-    def DownloadFinished(self, path, info):
+    def DownloadFinished(self, path, *info):
         """Fire a signal to notify that a download has finished."""
 
     @signal
@@ -312,7 +317,7 @@
         """Fire a signal to notify about an upload progress."""
 
     @signal
-    def UploadFinished(self, path, info):
+    def UploadFinished(self, path, *info):
         """Fire a signal to notify that an upload has finished."""
 
     @signal

=== modified file 'ubuntuone/platform/os_helper/__init__.py'
--- ubuntuone/platform/os_helper/__init__.py	2012-06-22 19:37:36 +0000
+++ ubuntuone/platform/os_helper/__init__.py	2012-08-22 18:22:29 +0000
@@ -73,6 +73,7 @@
 
 # Decorators
 
+get_os_valid_path = source.get_os_valid_path
 is_valid_syncdaemon_path = source.is_valid_syncdaemon_path
 is_valid_os_path = source.is_valid_os_path
 os_path = source.os_path

=== modified file 'ubuntuone/platform/os_helper/darwin.py'
--- ubuntuone/platform/os_helper/darwin.py	2012-07-10 18:41:15 +0000
+++ ubuntuone/platform/os_helper/darwin.py	2012-08-22 18:22:29 +0000
@@ -29,8 +29,8 @@
 """
 Darwin import for ubuntuone-client
 
-This module has to have all darwin specific modules and provide the api required
-to support the darwin platform.
+This module has to have all darwin specific modules and provide the
+api required to support the darwin platform.
 """
 
 import errno
@@ -70,6 +70,7 @@
 is_root = unix.is_root
 get_path_list = unix.get_path_list
 normpath = unix.normpath
+get_os_valid_path = unix.get_os_valid_path
 
 
 def move_to_trash(path):
@@ -121,6 +122,8 @@
 def is_valid_os_path(path_indexes=None):
     def decorator(func):
         def wrapped(*args, **kwargs):
+            for i in path_indexes:
+                assert isinstance(args[i], str), 'Path %r should be str.'
             return func(*args, **kwargs)
         return wrapped
     return decorator

=== modified file 'ubuntuone/platform/os_helper/linux.py'
--- ubuntuone/platform/os_helper/linux.py	2012-06-27 12:51:20 +0000
+++ ubuntuone/platform/os_helper/linux.py	2012-08-22 18:22:29 +0000
@@ -123,6 +123,7 @@
 is_root = unix.is_root
 get_path_list = unix.get_path_list
 normpath = unix.normpath
+get_os_valid_path = unix.get_os_valid_path
 is_valid_syncdaemon_path = None
 is_valid_os_path = None
 os_path = None

=== modified file 'ubuntuone/platform/os_helper/unix.py'
--- ubuntuone/platform/os_helper/unix.py	2012-06-27 14:02:14 +0000
+++ ubuntuone/platform/os_helper/unix.py	2012-08-22 18:22:29 +0000
@@ -185,3 +185,8 @@
 def normpath(path):
     """Normalize path, eliminating double slashes, etc."""
     return os.path.normpath(path)
+
+
+def get_os_valid_path(path):
+    """Return a valid os path."""
+    return os.path.abspath(path)

=== modified file 'ubuntuone/platform/os_helper/windows.py'
--- ubuntuone/platform/os_helper/windows.py	2012-07-03 17:16:57 +0000
+++ ubuntuone/platform/os_helper/windows.py	2012-08-22 18:22:29 +0000
@@ -249,6 +249,8 @@
     assert_windows_path(result)
     return result
 
+get_os_valid_path = get_windows_valid_path
+
 
 def _unicode_to_bytes(path):
     """Convert a unicode path to a bytes path."""

=== modified file 'ubuntuone/platform/tools/__init__.py'
--- ubuntuone/platform/tools/__init__.py	2012-05-30 15:35:49 +0000
+++ ubuntuone/platform/tools/__init__.py	2012-08-22 18:22:29 +0000
@@ -326,6 +326,13 @@
 
     @defer.inlineCallbacks
     @log_call(logger.debug)
+    def sync_menu(self):
+        """Return a deferred that will be fired with the sync menu data."""
+        results = yield self.proxy.call_method('status', 'sync_menu')
+        defer.returnValue(results)
+
+    @defer.inlineCallbacks
+    @log_call(logger.debug)
     def accept_share(self, share_id):
         """Accept the share with id: share_id."""
         d = self.wait_for_signals(signal_ok='ShareAnswerResponse',

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/status/aggregator.py	2012-08-22 18:22:29 +0000
@@ -33,7 +33,7 @@
 import itertools
 import operator
 import os
-
+from collections import deque
 
 import gettext
 
@@ -624,6 +624,7 @@
         self.finished_delay = 10
         self.progress = {}
         self.to_do = {}
+        self.recent_transfers = deque(maxlen=5)
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -775,6 +776,7 @@
         if command.deflated_size is not None:
             self.progress[
                 (command.share_id, command.node_id)] = command.deflated_size
+        self.recent_transfers.append(command.path)
         logger.debug("unqueueing command: %s", command.__class__.__name__)
         self.update_progressbar()
 
@@ -806,6 +808,19 @@
         self.messaging = Messaging()
         self.quota_timer = None
 
+    def recent_transfers(self):
+        """Return a tuple with the recent transfers paths."""
+        return list(self.aggregator.recent_transfers)
+
+    def files_uploading(self):
+        """Return a list with the files being uploading."""
+        uploading = []
+        for upload in self.aggregator.files_uploading:
+            if upload.size != 0:
+                uploading.append((upload.path, upload.size,
+                    upload.n_bytes_written))
+        return uploading
+
     def file_published(self, public_url):
         """A file was published."""
         status_event = FilePublishingStatus(new_public_url=public_url)

=== modified file 'ubuntuone/syncdaemon/__init__.py'
--- ubuntuone/syncdaemon/__init__.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/__init__.py	2012-08-22 18:22:29 +0000
@@ -36,3 +36,8 @@
                            "volumes",
                            "generations",
                           ])
+
+
+#Sync Menu data constants
+RECENT_TRANSFERS = 'recent-transfers'
+UPLOADING = 'uploading'

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2012-07-31 08:26:30 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2012-08-22 18:22:29 +0000
@@ -159,6 +159,7 @@
 
     'FSM_FILE_CONFLICT': ('old_name', 'new_name'),
     'FSM_DIR_CONFLICT': ('old_name', 'new_name'),
+    'FSM_PARTIAL_COMMITED': ('share_id', 'node_id'),
 
     'VM_UDF_SUBSCRIBED': ('udf',),
     'VM_UDF_SUBSCRIBE_ERROR': ('udf_id', 'error'),

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2012-06-22 11:29:10 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2012-08-22 18:22:29 +0000
@@ -1142,7 +1142,7 @@
         return fd
 
     def commit_partial(self, node_id, share_id, local_hash):
-        """Create a .partial in disk and set the flag in metadata."""
+        """Commit a file from a .partial to disk."""
         mdid = self._idx_node_id[(share_id, node_id)]
         mdobj = self.fs[mdid]
         if mdobj["is_dir"]:
@@ -1166,6 +1166,8 @@
         mdobj["info"]["is_partial"] = False
         mdobj["stat"] = get_stat(path)
         self.fs[mdid] = mdobj
+        self.eq.push("FSM_PARTIAL_COMMITED", share_id=share_id,
+                     node_id=node_id)
 
     def remove_partial(self, node_id, share_id):
         """Remove a .partial in disk and set the flag in metadata."""

=== modified file 'ubuntuone/syncdaemon/interaction_interfaces.py'
--- ubuntuone/syncdaemon/interaction_interfaces.py	2012-05-22 14:07:55 +0000
+++ ubuntuone/syncdaemon/interaction_interfaces.py	2012-08-22 18:22:29 +0000
@@ -302,6 +302,10 @@
                 waiting_content.append(data)
         return waiting_content
 
+    def sync_menu(self):
+        """Return the info necessary to construct the menu."""
+        return self.main.status_listener.menu_data()
+
 
 class SyncdaemonFileSystem(SyncdaemonObject):
     """An interface to the FileSystem Manager."""
@@ -816,8 +820,8 @@
         self._path_from_ids(share_id, node_id, 'DownloadFileProgress', info)
 
     @log_call(logger.debug)
-    def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
-        """Handle AQ_DOWNLOAD_FINISHED."""
+    def handle_FSM_PARTIAL_COMMITED(self, share_id, node_id):
+        """Handle FSM_PARTIAL_COMMITED."""
         self._path_from_ids(share_id, node_id, 'DownloadFinished', info={})
 
     @log_call(logger.debug)

=== modified file 'ubuntuone/syncdaemon/status_listener.py'
--- ubuntuone/syncdaemon/status_listener.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/status_listener.py	2012-08-22 18:22:29 +0000
@@ -31,7 +31,12 @@
 """Listener for event queue that updates the UI to show syncdaemon status."""
 
 from ubuntuone.status.aggregator import StatusFrontend
-from ubuntuone.syncdaemon import action_queue, config
+from ubuntuone.syncdaemon import (
+    action_queue,
+    config,
+    RECENT_TRANSFERS,
+    UPLOADING,
+)
 from ubuntuone.syncdaemon.interaction_interfaces import (
     get_share_dict, get_udf_dict)
 from ubuntuone.syncdaemon.volume_manager import UDF, Root
@@ -66,6 +71,13 @@
         user_conf = config.get_user_config()
         self.show_all_notifications = user_conf.get_show_all_notifications()
 
+    def menu_data(self):
+        """Return the info necessary to construct the sync menu."""
+        uploading = self.status_frontend.files_uploading()
+        transfers = self.status_frontend.recent_transfers()
+        data = {RECENT_TRANSFERS: transfers, UPLOADING: uploading}
+        return data
+
     def get_show_all_notifications(self):
         """Get the value of show_all_notifications."""
         return self._show_all_notifications

=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2012-05-14 21:24:24 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2012-08-22 18:22:29 +0000
@@ -1207,6 +1207,10 @@
         if is_link(path):
             return (False, "UDFs can not be a symlink")
 
+        # check if path exists but is not a directory
+        if path_exists(path) and not os.path.isdir(path):
+            return (False, "The path exists but is not a folder")
+
         # check if the path it's ok (outside root and
         # isn't a ancestor or child of another UDF)
         if self._is_nested_udf(path):