src/allmydata/test/test_magic_folder.py

   1
   2 import os, sys
   3
   4 from twisted.trial import unittest
   5 from twisted.internet import defer, task
   6
   7 from allmydata.interfaces import IDirectoryNode
   8 from allmydata.util.assertutil import precondition
   9
  10 from allmydata.util import fake_inotify, fileutil
  11 from allmydata.util.deferredutil import DeferredListShouldSucceed
  12 from allmydata.util.encodingutil import get_filesystem_encoding, to_filepath
  13 from allmydata.util.consumer import download_to_data
  14 from allmydata.test.no_network import GridTestMixin
  15 from allmydata.test.common_util import ReallyEqualMixin, NonASCIIPathMixin
  16 from allmydata.test.common import ShouldFailMixin
  17 from .test_cli_magic_folder import MagicFolderCLITestMixin
  18
  19 from allmydata.frontends import magic_folder
  20 from allmydata.frontends.magic_folder import MagicFolder, Downloader, WriteFileMixin
  21 from allmydata import magicfolderdb, magicpath
  22 from allmydata.util.fileutil import abspath_expanduser_unicode
  23 from allmydata.immutable.upload import Data
  24
  25
  26 class MagicFolderTestMixin(MagicFolderCLITestMixin, ShouldFailMixin, ReallyEqualMixin, NonASCIIPathMixin):
  27     """
  28     These tests will be run both with a mock notifier, and (on platforms that support it)
  29     with the real INotify.
  30     """
  31
  32     def setUp(self):
  33         GridTestMixin.setUp(self)
  34         temp = self.mktemp()
  35         self.basedir = abspath_expanduser_unicode(temp.decode(get_filesystem_encoding()))
  36         self.magicfolder = None
  37         self.patch(Downloader, 'REMOTE_SCAN_INTERVAL', 0)
  38
  39     def _get_count(self, name, client=None):
  40         counters = (client or self.get_client()).stats_provider.get_stats()["counters"]
  41         return counters.get('magic_folder.%s' % (name,), 0)
  42
  43     def _createdb(self):
  44         dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.basedir)
  45         mdb = magicfolderdb.get_magicfolderdb(dbfile, create_version=(magicfolderdb.SCHEMA_v1, 1))
  46         self.failUnless(mdb, "unable to create magicfolderdb from %r" % (dbfile,))
  47         self.failUnlessEqual(mdb.VERSION, 1)
  48         return mdb
  49
  50     def _restart_client(self, ign):
  51         #print "_restart_client"
  52         d = self.restart_client()
  53         d.addCallback(self._wait_until_started)
  54         return d
  55
  56     def _wait_until_started(self, ign):
  57         #print "_wait_until_started"
  58         self.magicfolder = self.get_client().getServiceNamed('magic-folder')
  59         return self.magicfolder.ready()
  60
  61     def test_db_basic(self):
  62         fileutil.make_dirs(self.basedir)
  63         self._createdb()
  64
  65     def test_db_persistence(self):
  66         """Test that a file upload creates an entry in the database."""
  67
  68         fileutil.make_dirs(self.basedir)
  69         db = self._createdb()
  70
  71         relpath1 = u"myFile1"
  72         pathinfo = fileutil.PathInfo(isdir=False, isfile=True, islink=False,
  73                                      exists=True, size=1, mtime=123, ctime=456)
  74         db.did_upload_version(relpath1, 0, 'URI:LIT:1', 'URI:LIT:0', 0, pathinfo)
  75
  76         c = db.cursor
  77         c.execute("SELECT size, mtime, ctime"
  78                   " FROM local_files"
  79                   " WHERE path=?",
  80                   (relpath1,))
  81         row = c.fetchone()
  82         self.failUnlessEqual(row, (pathinfo.size, pathinfo.mtime, pathinfo.ctime))
  83
  84         # Second test uses db.is_new_file instead of SQL query directly
  85         # to confirm the previous upload entry in the db.
  86         relpath2 = u"myFile2"
  87         path2 = os.path.join(self.basedir, relpath2)
  88         fileutil.write(path2, "meow\n")
  89         pathinfo = fileutil.get_pathinfo(path2)
  90         db.did_upload_version(relpath2, 0, 'URI:LIT:2', 'URI:LIT:1', 0, pathinfo)
  91         self.failUnlessFalse(db.is_new_file(pathinfo, relpath2))
  92
  93         different_pathinfo = fileutil.PathInfo(isdir=False, isfile=True, islink=False,
  94                                                exists=True, size=0, mtime=pathinfo.mtime, ctime=pathinfo.ctime)
  95         self.failUnlessTrue(db.is_new_file(different_pathinfo, relpath2))
  96
  97     def test_magicfolder_start_service(self):
  98         self.set_up_grid()
  99
 100         self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
 101                                                     base=self.basedir)
 102         self.mkdir_nonascii(self.local_dir)
 103
 104         d = defer.succeed(None)
 105         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 0))
 106
 107         d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
 108         d.addCallback(self._restart_client)
 109
 110         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 1))
 111         d.addBoth(self.cleanup)
 112         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 0))
 113         return d
 114
 115     def test_move_tree(self):
 116         self.set_up_grid()
 117
 118         self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
 119                                                     base=self.basedir)
 120         self.mkdir_nonascii(self.local_dir)
 121
 122         empty_tree_name = self.unicode_or_fallback(u"empty_tr\u00EAe", u"empty_tree")
 123         empty_tree_dir = abspath_expanduser_unicode(empty_tree_name, base=self.basedir)
 124         new_empty_tree_dir = abspath_expanduser_unicode(empty_tree_name, base=self.local_dir)
 125
 126         small_tree_name = self.unicode_or_fallback(u"small_tr\u00EAe", u"empty_tree")
 127         small_tree_dir = abspath_expanduser_unicode(small_tree_name, base=self.basedir)
 128         new_small_tree_dir = abspath_expanduser_unicode(small_tree_name, base=self.local_dir)
 129
 130         d = self.create_invite_join_magic_folder(u"Alice", self.local_dir)
 131         d.addCallback(self._restart_client)
 132
 133         def _check_move_empty_tree(res):
 134             print "_check_move_empty_tree"
 135             downloaded_d = self.magicfolder.downloader.set_hook('processed')
 136             uploaded_d = self.magicfolder.uploader.set_hook('processed')
 137             self.mkdir_nonascii(empty_tree_dir)
 138             os.rename(empty_tree_dir, new_empty_tree_dir)
 139             self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_TO)
 140
 141             return DeferredListShouldSucceed([downloaded_d, uploaded_d])
 142         d.addCallback(_check_move_empty_tree)
 143         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 144         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 145         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 0))
 146         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 147         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 1))
 148
 149         # FIXME check that Bob downloaded/created the empty tree.
 150
 151         def _check_move_small_tree(res):
 152             print "_check_move_small_tree"
 153             downloaded_d = self.magicfolder.downloader.set_hook('processed', ignore_count=1)
 154             uploaded_d = self.magicfolder.uploader.set_hook('processed', ignore_count=1)
 155             self.mkdir_nonascii(small_tree_dir)
 156             what_path = abspath_expanduser_unicode(u"what", base=small_tree_dir)
 157             fileutil.write(what_path, "say when")
 158             os.rename(small_tree_dir, new_small_tree_dir)
 159             self.notify(to_filepath(new_small_tree_dir), self.inotify.IN_MOVED_TO)
 160
 161             return DeferredListShouldSucceed([downloaded_d, uploaded_d])
 162         d.addCallback(_check_move_small_tree)
 163         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 164         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 3))
 165         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 1))
 166         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 167         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 168
 169         def _check_moved_tree_is_watched(res):
 170             print "_check_moved_tree_is_watched"
 171             downloaded_d = self.magicfolder.downloader.set_hook('processed', ignore_count=1)
 172             uploaded_d = self.magicfolder.uploader.set_hook('processed')
 173             another_path = abspath_expanduser_unicode(u"another", base=new_small_tree_dir)
 174             fileutil.write(another_path, "file")
 175             self.notify(to_filepath(another_path), self.inotify.IN_CLOSE_WRITE)
 176
 177             return DeferredListShouldSucceed([downloaded_d, uploaded_d])
 178         d.addCallback(_check_moved_tree_is_watched)
 179         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 180         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 181         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 182         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 183         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 184
 185         # Files that are moved out of the upload directory should no longer be watched.
 186         #def _move_dir_away(ign):
 187         #    os.rename(new_empty_tree_dir, empty_tree_dir)
 188         #    # Wuh? Why don't we get this event for the real test?
 189         #    #self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_FROM)
 190         #d.addCallback(_move_dir_away)
 191         #def create_file(val):
 192         #    test_file = abspath_expanduser_unicode(u"what", base=empty_tree_dir)
 193         #    fileutil.write(test_file, "meow")
 194         #    #self.notify(...)
 195         #    return
 196         #d.addCallback(create_file)
 197         #d.addCallback(lambda ign: time.sleep(1))  # XXX ICK
 198         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 199         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 200         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 201         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 202         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 203
 204         d.addBoth(self.cleanup)
 205         return d
 206
 207     def test_persistence(self):
 208         """
 209         Perform an upload of a given file and then stop the client.
 210         Start a new client and magic-folder service... and verify that the file is NOT uploaded
 211         a second time. This test is meant to test the database persistence along with
 212         the startup and shutdown code paths of the magic-folder service.
 213         """
 214         self.set_up_grid()
 215         self.local_dir = abspath_expanduser_unicode(u"test_persistence", base=self.basedir)
 216         self.mkdir_nonascii(self.local_dir)
 217         self.collective_dircap = ""
 218
 219         d = defer.succeed(None)
 220         d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
 221         d.addCallback(self._restart_client)
 222
 223         def create_test_file(filename):
 224             d2 = self.magicfolder.uploader.set_hook('processed')
 225             test_file = abspath_expanduser_unicode(filename, base=self.local_dir)
 226             fileutil.write(test_file, "meow %s" % filename)
 227             self.notify(to_filepath(test_file), self.inotify.IN_CLOSE_WRITE)
 228             return d2
 229         d.addCallback(lambda ign: create_test_file(u"what1"))
 230         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 231         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 232         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 233         d.addCallback(self.cleanup)
 234
 235         d.addCallback(self._restart_client)
 236         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 237         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 238         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 239         d.addCallback(lambda ign: create_test_file(u"what2"))
 240         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 241         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 2))
 242         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 243         d.addBoth(self.cleanup)
 244         return d
 245
 246     @defer.inlineCallbacks
 247     def test_delete(self):
 248         self.set_up_grid()
 249         self.local_dir = os.path.join(self.basedir, u"local_dir")
 250         self.mkdir_nonascii(self.local_dir)
 251
 252         yield self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
 253         yield self._restart_client(None)
 254
 255         try:
 256             # create a file
 257             up_proc = self.magicfolder.uploader.set_hook('processed')
 258             # down_proc = self.magicfolder.downloader.set_hook('processed')
 259             path = os.path.join(self.local_dir, u'foo')
 260             fileutil.write(path, 'foo\n')
 261             self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
 262             yield up_proc
 263             self.assertTrue(os.path.exists(path))
 264
 265             # the real test part: delete the file
 266             up_proc = self.magicfolder.uploader.set_hook('processed')
 267             os.unlink(path)
 268             self.notify(to_filepath(path), self.inotify.IN_DELETE)
 269             yield up_proc
 270             self.assertFalse(os.path.exists(path))
 271
 272             # ensure we still have a DB entry, and that the version is 1
 273             node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
 274             self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
 275             self.failUnlessEqual(metadata['version'], 1)
 276
 277         finally:
 278             yield self.cleanup(None)
 279
 280     @defer.inlineCallbacks
 281     def test_delete_and_restore(self):
 282         self.set_up_grid()
 283         self.local_dir = os.path.join(self.basedir, u"local_dir")
 284         self.mkdir_nonascii(self.local_dir)
 285
 286         yield self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
 287         yield self._restart_client(None)
 288
 289         try:
 290             # create a file
 291             up_proc = self.magicfolder.uploader.set_hook('processed')
 292             # down_proc = self.magicfolder.downloader.set_hook('processed')
 293             path = os.path.join(self.local_dir, u'foo')
 294             fileutil.write(path, 'foo\n')
 295             self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
 296             yield up_proc
 297             self.assertTrue(os.path.exists(path))
 298
 299             # delete the file
 300             up_proc = self.magicfolder.uploader.set_hook('processed')
 301             os.unlink(path)
 302             self.notify(to_filepath(path), self.inotify.IN_DELETE)
 303             yield up_proc
 304             self.assertFalse(os.path.exists(path))
 305
 306             # ensure we still have a DB entry, and that the version is 1
 307             node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
 308             self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
 309             self.failUnlessEqual(metadata['version'], 1)
 310
 311             # restore the file, with different contents
 312             up_proc = self.magicfolder.uploader.set_hook('processed')
 313             path = os.path.join(self.local_dir, u'foo')
 314             fileutil.write(path, 'bar\n')
 315             self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
 316             yield up_proc
 317
 318             # ensure we still have a DB entry, and that the version is 2
 319             node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
 320             self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
 321             self.failUnlessEqual(metadata['version'], 2)
 322
 323         finally:
 324             yield self.cleanup(None)
 325
 326
 327     @defer.inlineCallbacks
 328     def test_alice_delete_bob_restore(self):
 329         alice_clock = task.Clock()
 330         bob_clock = task.Clock()
 331         yield self.setup_alice_and_bob(alice_clock, bob_clock)
 332         alice_dir = self.alice_magicfolder.uploader._local_path_u
 333         bob_dir = self.bob_magicfolder.uploader._local_path_u
 334         alice_fname = os.path.join(alice_dir, 'blam')
 335         bob_fname = os.path.join(bob_dir, 'blam')
 336
 337         try:
 338             # alice creates a file, bob downloads it
 339             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 340             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 341
 342             fileutil.write(alice_fname, 'contents0\n')
 343             self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 344
 345             alice_clock.advance(0)
 346             yield alice_proc  # alice uploads
 347
 348             bob_clock.advance(0)
 349             yield bob_proc    # bob downloads
 350
 351             # check the state
 352             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 353             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
 354             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 355             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
 356             yield self.failUnlessReallyEqual(
 357                 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
 358                 0
 359             )
 360             yield self.failUnlessReallyEqual(
 361                 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
 362                 1
 363             )
 364
 365             print("BOB DELETE")
 366             # now bob deletes it (bob should upload, alice download)
 367             bob_proc = self.bob_magicfolder.uploader.set_hook('processed')
 368             alice_proc = self.alice_magicfolder.downloader.set_hook('processed')
 369             os.unlink(bob_fname)
 370             self.notify(to_filepath(bob_fname), self.inotify.IN_DELETE, magic=self.bob_magicfolder)
 371
 372             bob_clock.advance(0)
 373             yield bob_proc
 374             alice_clock.advance(0)
 375             yield alice_proc
 376
 377             # check versions
 378             node, metadata = yield self.alice_magicfolder.downloader._get_collective_latest_file(u'blam')
 379             self.assertTrue(metadata['deleted'])
 380             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 381             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
 382             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 383             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
 384
 385             print("ALICE RESTORE")
 386             # now alice restores it (alice should upload, bob download)
 387             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 388             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 389             fileutil.write(alice_fname, 'new contents\n')
 390             self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 391
 392             alice_clock.advance(0)
 393             yield alice_proc
 394             bob_clock.advance(0)
 395             yield bob_proc
 396
 397             # check versions
 398             node, metadata = yield self.alice_magicfolder.downloader._get_collective_latest_file(u'blam')
 399             self.assertTrue('deleted' not in metadata or not metadata['deleted'])
 400             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 2)
 401             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 2)
 402             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 2)
 403             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 2)
 404
 405         finally:
 406             # cleanup
 407             d0 = self.alice_magicfolder.finish()
 408             alice_clock.advance(0)
 409             yield d0
 410
 411             d1 = self.bob_magicfolder.finish()
 412             bob_clock.advance(0)
 413             yield d1
 414
 415     @defer.inlineCallbacks
 416     def test_alice_create_bob_update(self):
 417         alice_clock = task.Clock()
 418         bob_clock = task.Clock()
 419         yield self.setup_alice_and_bob(alice_clock, bob_clock)
 420         alice_dir = self.alice_magicfolder.uploader._local_path_u
 421         bob_dir = self.bob_magicfolder.uploader._local_path_u
 422         alice_fname = os.path.join(alice_dir, 'blam')
 423         bob_fname = os.path.join(bob_dir, 'blam')
 424
 425         try:
 426             # alice creates a file, bob downloads it
 427             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 428             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 429
 430             fileutil.write(alice_fname, 'contents0\n')
 431             self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 432
 433             alice_clock.advance(0)
 434             yield alice_proc  # alice uploads
 435
 436             bob_clock.advance(0)
 437             yield bob_proc    # bob downloads
 438
 439             # check the state
 440             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 441             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
 442             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 443             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
 444             yield self.failUnlessReallyEqual(
 445                 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
 446                 0
 447             )
 448             yield self.failUnlessReallyEqual(
 449                 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
 450                 1
 451             )
 452
 453             # now bob updates it (bob should upload, alice download)
 454             bob_proc = self.bob_magicfolder.uploader.set_hook('processed')
 455             alice_proc = self.alice_magicfolder.downloader.set_hook('processed')
 456             fileutil.write(bob_fname, 'bob wuz here\n')
 457             self.notify(to_filepath(bob_fname), self.inotify.IN_CLOSE_WRITE, magic=self.bob_magicfolder)
 458
 459             bob_clock.advance(0)
 460             yield bob_proc
 461             alice_clock.advance(0)
 462             yield alice_proc
 463
 464             # check the state
 465             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 466             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
 467             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 468             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
 469
 470         finally:
 471             # cleanup
 472             d0 = self.alice_magicfolder.finish()
 473             alice_clock.advance(0)
 474             yield d0
 475
 476             d1 = self.bob_magicfolder.finish()
 477             bob_clock.advance(0)
 478             yield d1
 479
 480     @defer.inlineCallbacks
 481     def test_alice_delete_and_restore(self):
 482         alice_clock = task.Clock()
 483         bob_clock = task.Clock()
 484         yield self.setup_alice_and_bob(alice_clock, bob_clock)
 485         alice_dir = self.alice_magicfolder.uploader._local_path_u
 486         bob_dir = self.bob_magicfolder.uploader._local_path_u
 487         alice_fname = os.path.join(alice_dir, 'blam')
 488         bob_fname = os.path.join(bob_dir, 'blam')
 489
 490         try:
 491             # alice creates a file, bob downloads it
 492             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 493             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 494
 495             fileutil.write(alice_fname, 'contents0\n')
 496             self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 497
 498             alice_clock.advance(0)
 499             yield alice_proc  # alice uploads
 500
 501             bob_clock.advance(0)
 502             yield bob_proc    # bob downloads
 503
 504             # check the state
 505             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 506             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
 507             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 508             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
 509             yield self.failUnlessReallyEqual(
 510                 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
 511                 0
 512             )
 513             yield self.failUnlessReallyEqual(
 514                 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
 515                 1
 516             )
 517             self.failUnless(os.path.exists(bob_fname))
 518
 519             # now alice deletes it (alice should upload, bob download)
 520             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 521             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 522             os.unlink(alice_fname)
 523             self.notify(to_filepath(alice_fname), self.inotify.IN_DELETE, magic=self.alice_magicfolder)
 524
 525             alice_clock.advance(0)
 526             yield alice_proc
 527             bob_clock.advance(0)
 528             yield bob_proc
 529
 530             # check the state
 531             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
 532             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
 533             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
 534             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
 535             self.failIf(os.path.exists(bob_fname))
 536
 537             # now alice restores the file (with new contents)
 538             alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
 539             bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
 540             fileutil.write(alice_fname, 'alice wuz here\n')
 541             self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 542
 543             alice_clock.advance(0)
 544             yield alice_proc
 545             bob_clock.advance(0)
 546             yield bob_proc
 547
 548             # check the state
 549             yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 2)
 550             yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 2)
 551             yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 2)
 552             yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 2)
 553             self.failUnless(os.path.exists(bob_fname))
 554
 555         finally:
 556             # cleanup
 557             d0 = self.alice_magicfolder.finish()
 558             alice_clock.advance(0)
 559             yield d0
 560
 561             d1 = self.bob_magicfolder.finish()
 562             bob_clock.advance(0)
 563             yield d1
 564
 565     def test_magic_folder(self):
 566         self.set_up_grid()
 567         self.local_dir = os.path.join(self.basedir, self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir"))
 568         self.mkdir_nonascii(self.local_dir)
 569
 570         d = self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
 571         d.addCallback(self._restart_client)
 572
 573         # Write something short enough for a LIT file.
 574         d.addCallback(lambda ign: self._check_file(u"short", "test"))
 575
 576         # Write to the same file again with different data.
 577         d.addCallback(lambda ign: self._check_file(u"short", "different"))
 578
 579         # Test that temporary files are not uploaded.
 580         d.addCallback(lambda ign: self._check_file(u"tempfile", "test", temporary=True))
 581
 582         # Test creation of a subdirectory.
 583         d.addCallback(lambda ign: self._check_mkdir(u"directory"))
 584
 585         # Write something longer, and also try to test a Unicode name if the fs can represent it.
 586         name_u = self.unicode_or_fallback(u"l\u00F8ng", u"long")
 587         d.addCallback(lambda ign: self._check_file(name_u, "test"*100))
 588
 589         # TODO: test that causes an upload failure.
 590         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 591
 592         d.addBoth(self.cleanup)
 593         return d
 594
 595     def _check_mkdir(self, name_u):
 596         return self._check_file(name_u + u"/", "", directory=True)
 597
 598     def _check_file(self, name_u, data, temporary=False, directory=False):
 599         precondition(not (temporary and directory), temporary=temporary, directory=directory)
 600
 601         previously_uploaded = self._get_count('uploader.objects_succeeded')
 602         previously_disappeared = self._get_count('uploader.objects_disappeared')
 603
 604         d = self.magicfolder.uploader.set_hook('processed')
 605
 606         path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
 607         path = to_filepath(path_u)
 608
 609         if directory:
 610             os.mkdir(path_u)
 611             event_mask = self.inotify.IN_CREATE | self.inotify.IN_ISDIR
 612         else:
 613             # We don't use FilePath.setContent() here because it creates a temporary file that
 614             # is renamed into place, which causes events that the test is not expecting.
 615             f = open(path_u, "wb")
 616             try:
 617                 if temporary and sys.platform != "win32":
 618                     os.unlink(path_u)
 619                 f.write(data)
 620             finally:
 621                 f.close()
 622             if temporary and sys.platform == "win32":
 623                 os.unlink(path_u)
 624                 self.notify(path, self.inotify.IN_DELETE, flush=False)
 625             event_mask = self.inotify.IN_CLOSE_WRITE
 626
 627         self.notify(path, event_mask)
 628         encoded_name_u = magicpath.path2magic(name_u)
 629
 630         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 631         if temporary:
 632             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
 633                                                                  previously_disappeared + 1))
 634         else:
 635             d.addCallback(lambda ign: self.upload_dirnode.get(encoded_name_u))
 636             d.addCallback(download_to_data)
 637             d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
 638             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
 639                                                                  previously_uploaded + 1))
 640
 641         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 642         return d
 643
 644     def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
 645         encoded_name_u = magicpath.path2magic(relpath_u)
 646         d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
 647         def check_latest(result):
 648             if result[0] is not None:
 649                 node, metadata = result
 650                 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
 651         d.addCallback(check_latest)
 652         return d
 653
 654     def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
 655         version = magicfolder._db.get_local_file_version(relpath_u)
 656         #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
 657         self.failUnlessEqual(version, expected_version)
 658
 659     def _check_file_gone(self, magicfolder, relpath_u):
 660         path = os.path.join(magicfolder.uploader._local_path_u, relpath_u)
 661         self.assertTrue(not os.path.exists(path))
 662
 663     def _check_uploader_count(self, name, expected, magic=None):
 664         self.failUnlessReallyEqual(self._get_count('uploader.'+name, client=(magic or self.alice_magicfolder)._client),
 665                                    expected)
 666
 667     def _check_downloader_count(self, name, expected, magic=None):
 668         self.failUnlessReallyEqual(self._get_count('downloader.'+name, client=(magic or self.bob_magicfolder)._client),
 669                                    expected)
 670
 671     def test_alice_bob(self):
 672         alice_clock = task.Clock()
 673         bob_clock = task.Clock()
 674         d = self.setup_alice_and_bob(alice_clock, bob_clock)
 675
 676         def _wait_for_Alice(ign, downloaded_d):
 677             print "Now waiting for Alice to download\n"
 678             alice_clock.advance(0)
 679             return downloaded_d
 680
 681         def _wait_for_Bob(ign, downloaded_d):
 682             print "Now waiting for Bob to download\n"
 683             bob_clock.advance(0)
 684             return downloaded_d
 685
 686         def _wait_for(ign, something_to_do, alice=True):
 687             if alice:
 688                 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
 689                 uploaded_d = self.alice_magicfolder.uploader.set_hook('processed')
 690             else:
 691                 downloaded_d = self.alice_magicfolder.downloader.set_hook('processed')
 692                 uploaded_d = self.bob_magicfolder.uploader.set_hook('processed')
 693             something_to_do()
 694             if alice:
 695                 print "Waiting for Alice to upload\n"
 696                 alice_clock.advance(0)
 697                 uploaded_d.addCallback(_wait_for_Bob, downloaded_d)
 698             else:
 699                 print "Waiting for Bob to upload\n"
 700                 bob_clock.advance(0)
 701                 uploaded_d.addCallback(_wait_for_Alice, downloaded_d)
 702             return uploaded_d
 703
 704         def Alice_to_write_a_file():
 705             print "Alice writes a file\n"
 706             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 707             fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
 708             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 709         d.addCallback(_wait_for, Alice_to_write_a_file)
 710
 711         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
 712         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
 713         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 714         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1))
 715         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1))
 716         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
 717         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
 718         d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0))
 719         d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0, magic=self.bob_magicfolder))
 720
 721         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
 722         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 723         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1))
 724         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 0, magic=self.bob_magicfolder))
 725
 726         def Alice_to_delete_file():
 727             print "Alice deletes the file!\n"
 728             os.unlink(self.file_path)
 729             self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE, magic=self.alice_magicfolder)
 730         d.addCallback(_wait_for, Alice_to_delete_file)
 731
 732         def notify_bob_moved(ign):
 733             d0 = self.bob_magicfolder.uploader.set_hook('processed')
 734             p = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
 735             self.notify(to_filepath(p), self.inotify.IN_MOVED_FROM, magic=self.bob_magicfolder, flush=False)
 736             self.notify(to_filepath(p + u'.backup'), self.inotify.IN_MOVED_TO, magic=self.bob_magicfolder)
 737             bob_clock.advance(0)
 738             return d0
 739         d.addCallback(notify_bob_moved)
 740
 741         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
 742         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
 743         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 744         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2))
 745         d.addCallback(lambda ign: self._check_uploader_count('objects_not_uploaded', 1, magic=self.bob_magicfolder))
 746         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1, magic=self.bob_magicfolder))
 747
 748         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
 749         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
 750         d.addCallback(lambda ign: self._check_file_gone(self.bob_magicfolder, u"file1"))
 751         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 752         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2))
 753
 754         def Alice_to_rewrite_file():
 755             print "Alice rewrites file\n"
 756             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 757             fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
 758             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 759         d.addCallback(_wait_for, Alice_to_rewrite_file)
 760
 761         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
 762         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
 763         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 764         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3))
 765         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 3))
 766         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
 767         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
 768         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 769         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 770
 771         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 2))
 772         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 2))
 773         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 774         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
 775
 776         path_u = u"/tmp/magic_folder_test"
 777         encoded_path_u = magicpath.path2magic(u"/tmp/magic_folder_test")
 778
 779         def Alice_tries_to_p0wn_Bob(ign):
 780             print "Alice tries to p0wn Bob\n"
 781             self.objects_excluded = self._get_count('downloader.objects_excluded', client=self.bob_magicfolder._client)
 782             processed_d = self.bob_magicfolder.downloader.set_hook('processed')
 783
 784             # upload a file that would provoke the security bug from #2506
 785             uploadable = Data("", self.alice_magicfolder._client.convergence)
 786             alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
 787
 788             d2 = alice_dmd.add_file(encoded_path_u, uploadable, metadata={"version": 0}, overwrite=True)
 789             d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
 790             d2.addCallback(_wait_for_Bob, processed_d)
 791             return d2
 792         d.addCallback(Alice_tries_to_p0wn_Bob)
 793
 794         d.addCallback(lambda ign: self.failIf(os.path.exists(path_u)))
 795         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, encoded_path_u, None))
 796         d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', self.objects_excluded+1))
 797         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
 798         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 799         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 800
 801         def Bob_to_rewrite_file():
 802             print "Bob rewrites file\n"
 803             self.file_path = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
 804             print "---- bob's file is %r" % (self.file_path,)
 805             fileutil.write(self.file_path, "No white rabbit to be found.")
 806             self.magicfolder = self.bob_magicfolder
 807             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 808         d.addCallback(lambda ign: _wait_for(None, Bob_to_rewrite_file, alice=False))
 809
 810         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 3))
 811         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 3))
 812         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
 813         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2, magic=self.bob_magicfolder))
 814         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1, magic=self.bob_magicfolder))
 815         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
 816         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
 817         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 818
 819         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 3))
 820         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 3))
 821         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
 822         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1, magic=self.alice_magicfolder))
 823         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 824
 825         def Alice_conflicts_with_Bob():
 826             print "Alice conflicts with Bob\n"
 827             downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
 828             uploadable = Data("do not follow the white rabbit", self.alice_magicfolder._client.convergence)
 829             alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
 830             d2 = alice_dmd.add_file(u"file1", uploadable,
 831                                     metadata={"version": 5,
 832                                               "last_downloaded_uri" : "URI:LIT:" },
 833                                     overwrite=True)
 834             print "Waiting for Alice to upload\n"
 835             d2.addCallback(lambda ign: bob_clock.advance(6))
 836             d2.addCallback(lambda ign: downloaded_d)
 837             d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
 838             return d2
 839
 840         d.addCallback(lambda ign: Alice_conflicts_with_Bob())
 841         # XXX fix the code so that it doesn't increment objects_excluded each turn
 842         #d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', 1))
 843         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 4))
 844         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 1))
 845
 846         def _cleanup(ign, magicfolder, clock):
 847             if magicfolder is not None:
 848                 d2 = magicfolder.finish()
 849                 clock.advance(0)
 850                 return d2
 851
 852         def cleanup_Alice_and_Bob(result):
 853             print "cleanup alice bob test\n"
 854             d = defer.succeed(None)
 855             d.addCallback(_cleanup, self.alice_magicfolder, alice_clock)
 856             d.addCallback(_cleanup, self.bob_magicfolder, bob_clock)
 857             d.addCallback(lambda ign: result)
 858             return d
 859         d.addBoth(cleanup_Alice_and_Bob)
 860         return d
 861
 862
 863 class MockTest(MagicFolderTestMixin, unittest.TestCase):
 864     """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
 865
 866     def setUp(self):
 867         MagicFolderTestMixin.setUp(self)
 868         self.inotify = fake_inotify
 869         self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
 870
 871     def notify(self, path, mask, magic=None, flush=True):
 872         if magic is None:
 873             magic = self.magicfolder
 874         magic.uploader._notifier.event(path, mask)
 875         # no flush for the mock test.
 876
 877     def test_errors(self):
 878         self.set_up_grid()
 879
 880         errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
 881         os.mkdir(errors_dir)
 882         not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
 883         fileutil.write(not_a_dir, "")
 884         magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
 885         doesnotexist  = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
 886
 887         client = self.g.clients[0]
 888         d = client.create_dirnode()
 889         def _check_errors(n):
 890             self.failUnless(IDirectoryNode.providedBy(n))
 891             upload_dircap = n.get_uri()
 892             readonly_dircap = n.get_readonly_uri()
 893
 894             self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
 895                             MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
 896             self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
 897                             MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
 898             self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
 899                             MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
 900             self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
 901                             MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
 902             self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
 903                             MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb,)
 904             self.shouldFail(AssertionError, 'collective dircap',
 905                             "The URI in '%s' is not a readonly cap to a directory." % os.path.join('private', 'collective_dircap'),
 906                             MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
 907
 908             def _not_implemented():
 909                 raise NotImplementedError("blah")
 910             self.patch(magic_folder, 'get_inotify_module', _not_implemented)
 911             self.shouldFail(NotImplementedError, 'unsupported', 'blah',
 912                             MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
 913         d.addCallback(_check_errors)
 914         return d
 915
 916     def test_write_downloaded_file(self):
 917         workdir = u"cli/MagicFolder/write-downloaded-file"
 918         local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
 919
 920         class TestWriteFileMixin(WriteFileMixin):
 921             def _log(self, msg):
 922                 pass
 923
 924         writefile = TestWriteFileMixin()
 925
 926         # create a file with name "foobar" with content "foo"
 927         # write downloaded file content "bar" into "foobar" with is_conflict = False
 928         fileutil.make_dirs(workdir)
 929         fileutil.write(local_file, "foo")
 930
 931         # if is_conflict is False, then the .conflict file shouldn't exist.
 932         writefile._write_downloaded_file(local_file, "bar", False, None)
 933         conflicted_path = local_file + u".conflict"
 934         self.failIf(os.path.exists(conflicted_path))
 935
 936         # At this point, the backup file should exist with content "foo"
 937         backup_path = local_file + u".backup"
 938         self.failUnless(os.path.exists(backup_path))
 939         self.failUnlessEqual(fileutil.read(backup_path), "foo")
 940
 941         # .tmp file shouldn't exist
 942         self.failIf(os.path.exists(local_file + u".tmp"))
 943
 944         # .. and the original file should have the new content
 945         self.failUnlessEqual(fileutil.read(local_file), "bar")
 946
 947         # now a test for conflicted case
 948         writefile._write_downloaded_file(local_file, "bar", True, None)
 949         self.failUnless(os.path.exists(conflicted_path))
 950
 951         # .tmp file shouldn't exist
 952         self.failIf(os.path.exists(local_file + u".tmp"))
 953
 954
 955 class RealTest(MagicFolderTestMixin, unittest.TestCase):
 956     """This is skipped unless both Twisted and the platform support inotify."""
 957
 958     def setUp(self):
 959         MagicFolderTestMixin.setUp(self)
 960         self.inotify = magic_folder.get_inotify_module()
 961
 962     def notify(self, path, mask, magic=None, flush=True):
 963         # Writing to the filesystem causes the notification.
 964         # However, flushing filesystem buffers may be necessary on Windows.
 965         if flush:
 966             fileutil.flush_volume(path)
 967
 968 try:
 969     magic_folder.get_inotify_module()
 970 except NotImplementedError:
 971     RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."