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