Merge lp:~diegosarmentero/ubuntuone-client/darwin-tests-refactoring into lp:ubuntuone-client

[Diego Sarmentero]

- Refactoring test for filesystem notifications

Put together the shared code between darwin and windows.

[Alejandro J. Cura (alecu)]

Great branch so far!

A few comments:
---

Why is self._assert_logs removed from many places in darwin.py?

---

There is no need for the empty setUp in TestNotifyProcessor.

review: Needs Information

[Manuel de la Peña (mandel)]

Lint:

PYTHONPATH=""::.:."" SRCDIR="." USE_PYFLAKES="true" u1lint
== Python Lint Notices ==

./ubuntuone/platform/filesystem_notifications/common.py:
    37: 'IN_MODIFY' imported but unused

make: *** [lint] Error 1

review: Needs Fixing

[Manuel de la Peña (mandel)]

Why are there some tests that are raising a not implemented error? Should they either be implemented (the tests) or not be there or be skipped?

review: Needs Information

[Manuel de la Peña (mandel)]

Do we still need the mask in the common code?

79 + self.mask = None

I mean, we never test on windows different masks, maybe a good way to simplify and unify the tests is to simply remove its need, right?

I really don't like code doing thins like this:

54 +filesystem_notifications = None
55 +NotifyProcessor = None
56 +Watch = None
57 +WatchManager = None
58 +get_os_valid_path = lambda x: x
59 +create_fake_event = None
60 +custom_process_events = None

This is the same issue we had with the common.py implementation, can't we do the same? Having windows and darwin set those values smells a little.

review: Needs Fixing

[Manuel de la Peña (mandel)]

Minor things:

+for key, value in filesystem_notifications.common.ACTIONS.iteritems():

can we use items, is less efficient but will make the work to port it to python3 easier.

The following confuses me:

+from ubuntuone.platform import os_helper
+get_os_valid_path = os_helper.get_os_valid_path

Can't we do:

from ubuntuone.platfor.os_helper import get_os_falid_path

Same comment for:

4 +NotifyProcessor = filesystem_notifications.common.NotifyProcessor
55 +Watch = filesystem_notifications.common.Watch
56 +WatchManager = filesystem_notifications.common.WatchManager

Can't we just import either common or wach of the objects form common?

Why was the timeout removed?

757 - timeout = 5

Ae we going to use the defaul twisted trial timeout, that is too long right?

Why is this back in common?

2306 + IN_MODIFY as in_modify,
2307 IN_MOVED_FROM,
2308 IN_MOVED_TO,
2309 )
2310 @@ -66,6 +67,12 @@
2311 else:
2312 raise ImportError('Not supported platform')
2313
2314 +
2315 +# This is done to avoid lint issues with pyflakes.
2316 +# And because all the other IN_* are being consumed from this module,
2317 +# it would be best if we do the same with IN_MODIFY.
2318 +IN_MODIFY = in_modify

I though we removed it and we not longer had issues with it.

review: Needs Fixing

[Diego Sarmentero (diegosarmentero)]

> Minor things:
>
> +for key, value in filesystem_notifications.common.ACTIONS.iteritems():
>
> can we use items, is less efficient but will make the work to port it to
> python3 easier.
>
> The following confuses me:
>
> +from ubuntuone.platform import os_helper
> +get_os_valid_path = os_helper.get_os_valid_path
>
> Can't we do:
>
> from ubuntuone.platfor.os_helper import get_os_falid_path
>
> Same comment for:
>
> 4 +NotifyProcessor = filesystem_notifications.common.NotifyProcessor
> 55 +Watch = filesystem_notifications.common.Watch
> 56 +WatchManager = filesystem_notifications.common.WatchManager
>
> Can't we just import either common or wach of the objects form common?
>
> Why was the timeout removed?
>
> 757 - timeout = 5
>
> Ae we going to use the defaul twisted trial timeout, that is too long right?

Fixed!

>
> Why is this back in common?
>
> 2306 + IN_MODIFY as in_modify,
> 2307 IN_MOVED_FROM,
> 2308 IN_MOVED_TO,
> 2309 )
> 2310 @@ -66,6 +67,12 @@
> 2311 else:
> 2312 raise ImportError('Not supported platform')
> 2313
> 2314 +
> 2315 +# This is done to avoid lint issues with pyflakes.
> 2316 +# And because all the other IN_* are being consumed from this module,
> 2317 +# it would be best if we do the same with IN_MODIFY.
> 2318 +IN_MODIFY = in_modify
>
> I though we removed it and we not longer had issues with it.

That should be there, if we remove that we are going to have pyflakes issues.

[Manuel de la Peña (mandel)]

Looks good to me.

review: Approve

[Alejandro J. Cura (alecu)]

After recent branches that landed on trunk this branch is giving merge errors.

review: Needs Fixing

[Alejandro J. Cura (alecu)]

Branch looks good now. Thanks a lot for working on this!

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~diegosarmentero/ubuntuone-client/darwin-tests-refactoring into lp:ubuntuone-client 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 ...

[Ubuntu One Auto Pilot (otto-pilot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

=== modified file 'run-mac-tests'
--- run-mac-tests	2012-07-30 19:31:32 +0000
+++ run-mac-tests	2012-08-06 16:57:22 +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-06 16:57:22 +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-06 16:57:22 +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):

=== 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-06 16:57:22 +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 '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-06 16:57:22 +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-06 16:57:22 +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/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-06 16:57:22 +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-06 16:57:22 +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-06 16:57:22 +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-06 16:57:22 +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-06 16:57:22 +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."""