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         print "%r._check_file(%r, %r, temporary=%r, directory=%r)" % (self, name_u, data, temporary, directory)
 602         previously_uploaded = self._get_count('uploader.objects_succeeded')
 603         previously_disappeared = self._get_count('uploader.objects_disappeared')
 604
 605         d = self.magicfolder.uploader.set_hook('processed')
 606
 607         path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
 608         path = to_filepath(path_u)
 609
 610         if directory:
 611             os.mkdir(path_u)
 612             event_mask = self.inotify.IN_CREATE | self.inotify.IN_ISDIR
 613         else:
 614             # We don't use FilePath.setContent() here because it creates a temporary file that
 615             # is renamed into place, which causes events that the test is not expecting.
 616             f = open(path_u, "wb")
 617             try:
 618                 if temporary and sys.platform != "win32":
 619                     os.unlink(path_u)
 620                 f.write(data)
 621             finally:
 622                 f.close()
 623             if temporary and sys.platform == "win32":
 624                 os.unlink(path_u)
 625                 self.notify(path, self.inotify.IN_DELETE, flush=False)
 626             event_mask = self.inotify.IN_CLOSE_WRITE
 627
 628         self.notify(path, event_mask)
 629         encoded_name_u = magicpath.path2magic(name_u)
 630
 631         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 632         if temporary:
 633             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
 634                                                                  previously_disappeared + 1))
 635         else:
 636             def _here(res, n):
 637                 print "here %r %r" % (n, res)
 638                 return res
 639             d.addBoth(_here, 1)
 640             d.addCallback(lambda ign: self.upload_dirnode.list())
 641             d.addBoth(_here, 1.5)
 642             d.addCallback(lambda ign: self.upload_dirnode.get(encoded_name_u))
 643             d.addBoth(_here, 2)
 644             d.addCallback(download_to_data)
 645             d.addBoth(_here, 3)
 646             d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
 647             d.addBoth(_here, 4)
 648             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
 649                                                                  previously_uploaded + 1))
 650
 651         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 652         return d
 653
 654     def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
 655         encoded_name_u = magicpath.path2magic(relpath_u)
 656         d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
 657         def check_latest(result):
 658             if result[0] is not None:
 659                 node, metadata = result
 660                 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
 661         d.addCallback(check_latest)
 662         return d
 663
 664     def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
 665         version = magicfolder._db.get_local_file_version(relpath_u)
 666         #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
 667         self.failUnlessEqual(version, expected_version)
 668
 669     def _check_file_gone(self, magicfolder, relpath_u):
 670         path = os.path.join(magicfolder.uploader._local_path_u, relpath_u)
 671         self.assertTrue(not os.path.exists(path))
 672
 673     def _check_uploader_count(self, name, expected, magic=None):
 674         self.failUnlessReallyEqual(self._get_count('uploader.'+name, client=(magic or self.alice_magicfolder)._client),
 675                                    expected)
 676
 677     def _check_downloader_count(self, name, expected, magic=None):
 678         self.failUnlessReallyEqual(self._get_count('downloader.'+name, client=(magic or self.bob_magicfolder)._client),
 679                                    expected)
 680
 681     def test_alice_bob(self):
 682         alice_clock = task.Clock()
 683         bob_clock = task.Clock()
 684         d = self.setup_alice_and_bob(alice_clock, bob_clock)
 685
 686         def _wait_for_Alice(ign, downloaded_d):
 687             print "Now waiting for Alice to download\n"
 688             alice_clock.advance(0)
 689             return downloaded_d
 690
 691         def _wait_for_Bob(ign, downloaded_d):
 692             print "Now waiting for Bob to download\n"
 693             bob_clock.advance(0)
 694             return downloaded_d
 695
 696         def _wait_for(ign, something_to_do, alice=True):
 697             if alice:
 698                 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
 699                 uploaded_d = self.alice_magicfolder.uploader.set_hook('processed')
 700             else:
 701                 downloaded_d = self.alice_magicfolder.downloader.set_hook('processed')
 702                 uploaded_d = self.bob_magicfolder.uploader.set_hook('processed')
 703             something_to_do()
 704             if alice:
 705                 print "Waiting for Alice to upload\n"
 706                 alice_clock.advance(0)
 707                 uploaded_d.addCallback(_wait_for_Bob, downloaded_d)
 708             else:
 709                 print "Waiting for Bob to upload\n"
 710                 bob_clock.advance(0)
 711                 uploaded_d.addCallback(_wait_for_Alice, downloaded_d)
 712             return uploaded_d
 713
 714         def Alice_to_write_a_file():
 715             print "Alice writes a file\n"
 716             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 717             fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
 718             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 719         d.addCallback(_wait_for, Alice_to_write_a_file)
 720
 721         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
 722         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
 723         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 724         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1))
 725         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1))
 726         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
 727         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
 728         d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0))
 729         d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0, magic=self.bob_magicfolder))
 730
 731         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
 732         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 733         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1))
 734         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 0, magic=self.bob_magicfolder))
 735
 736         def Alice_to_delete_file():
 737             print "Alice deletes the file!\n"
 738             os.unlink(self.file_path)
 739             self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE, magic=self.alice_magicfolder)
 740         d.addCallback(_wait_for, Alice_to_delete_file)
 741
 742         def notify_bob_moved(ign):
 743             d0 = self.bob_magicfolder.uploader.set_hook('processed')
 744             p = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
 745             self.notify(to_filepath(p), self.inotify.IN_MOVED_FROM, magic=self.bob_magicfolder, flush=False)
 746             self.notify(to_filepath(p + u'.backup'), self.inotify.IN_MOVED_TO, magic=self.bob_magicfolder)
 747             bob_clock.advance(0)
 748             return d0
 749         d.addCallback(notify_bob_moved)
 750
 751         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
 752         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
 753         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 754         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2))
 755         d.addCallback(lambda ign: self._check_uploader_count('objects_not_uploaded', 1, magic=self.bob_magicfolder))
 756         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1, magic=self.bob_magicfolder))
 757
 758         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
 759         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
 760         d.addCallback(lambda ign: self._check_file_gone(self.bob_magicfolder, u"file1"))
 761         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 762         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2))
 763
 764         def Alice_to_rewrite_file():
 765             print "Alice rewrites file\n"
 766             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 767             fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
 768             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
 769         d.addCallback(_wait_for, Alice_to_rewrite_file)
 770
 771         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
 772         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
 773         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
 774         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3))
 775         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 3))
 776         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
 777         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
 778         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 779         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 780
 781         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 2))
 782         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 2))
 783         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
 784         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
 785
 786         path_u = u"/tmp/magic_folder_test"
 787         encoded_path_u = magicpath.path2magic(u"/tmp/magic_folder_test")
 788
 789         def Alice_tries_to_p0wn_Bob(ign):
 790             print "Alice tries to p0wn Bob\n"
 791             self.objects_excluded = self._get_count('downloader.objects_excluded', client=self.bob_magicfolder._client)
 792             processed_d = self.bob_magicfolder.downloader.set_hook('processed')
 793
 794             # upload a file that would provoke the security bug from #2506
 795             uploadable = Data("", self.alice_magicfolder._client.convergence)
 796             alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
 797
 798             d2 = alice_dmd.add_file(encoded_path_u, uploadable, metadata={"version": 0}, overwrite=True)
 799             d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
 800             d2.addCallback(_wait_for_Bob, processed_d)
 801             return d2
 802         d.addCallback(Alice_tries_to_p0wn_Bob)
 803
 804         d.addCallback(lambda ign: self.failIf(os.path.exists(path_u)))
 805         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, encoded_path_u, None))
 806         d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', self.objects_excluded+1))
 807         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
 808         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 809         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 810
 811         def Bob_to_rewrite_file():
 812             print "Bob rewrites file\n"
 813             self.file_path = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
 814             print "---- bob's file is %r" % (self.file_path,)
 815             fileutil.write(self.file_path, "No white rabbit to be found.")
 816             self.magicfolder = self.bob_magicfolder
 817             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 818         d.addCallback(lambda ign: _wait_for(None, Bob_to_rewrite_file, alice=False))
 819
 820         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 3))
 821         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 3))
 822         d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
 823         d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2, magic=self.bob_magicfolder))
 824         d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1, magic=self.bob_magicfolder))
 825         d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
 826         d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
 827         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
 828
 829         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 3))
 830         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 3))
 831         d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
 832         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1, magic=self.alice_magicfolder))
 833         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
 834
 835         def Alice_conflicts_with_Bob():
 836             print "Alice conflicts with Bob\n"
 837             downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
 838             uploadable = Data("do not follow the white rabbit", self.alice_magicfolder._client.convergence)
 839             alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
 840             d2 = alice_dmd.add_file(u"file1", uploadable,
 841                                     metadata={"version": 5,
 842                                               "last_downloaded_uri" : "URI:LIT:" },
 843                                     overwrite=True)
 844             print "Waiting for Alice to upload\n"
 845             d2.addCallback(lambda ign: bob_clock.advance(6))
 846             d2.addCallback(lambda ign: downloaded_d)
 847             d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
 848             return d2
 849
 850         d.addCallback(lambda ign: Alice_conflicts_with_Bob())
 851         # XXX fix the code so that it doesn't increment objects_excluded each turn
 852         #d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', 1))
 853         d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 4))
 854         d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 1))
 855
 856         def _cleanup(ign, magicfolder, clock):
 857             if magicfolder is not None:
 858                 d2 = magicfolder.finish()
 859                 clock.advance(0)
 860                 return d2
 861
 862         def cleanup_Alice_and_Bob(result):
 863             print "cleanup alice bob test\n"
 864             d = defer.succeed(None)
 865             d.addCallback(_cleanup, self.alice_magicfolder, alice_clock)
 866             d.addCallback(_cleanup, self.bob_magicfolder, bob_clock)
 867             d.addCallback(lambda ign: result)
 868             return d
 869         d.addBoth(cleanup_Alice_and_Bob)
 870         return d
 871
 872
 873 class MockTest(MagicFolderTestMixin, unittest.TestCase):
 874     """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
 875
 876     def setUp(self):
 877         MagicFolderTestMixin.setUp(self)
 878         self.inotify = fake_inotify
 879         self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
 880
 881     def notify(self, path, mask, magic=None, flush=True):
 882         if magic is None:
 883             magic = self.magicfolder
 884         magic.uploader._notifier.event(path, mask)
 885         # no flush for the mock test.
 886
 887     def test_errors(self):
 888         self.set_up_grid()
 889
 890         errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
 891         os.mkdir(errors_dir)
 892         not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
 893         fileutil.write(not_a_dir, "")
 894         magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
 895         doesnotexist  = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
 896
 897         client = self.g.clients[0]
 898         d = client.create_dirnode()
 899         def _check_errors(n):
 900             self.failUnless(IDirectoryNode.providedBy(n))
 901             upload_dircap = n.get_uri()
 902             readonly_dircap = n.get_readonly_uri()
 903
 904             self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
 905                             MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
 906             self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
 907                             MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
 908             self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
 909                             MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
 910             self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
 911                             MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
 912             self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
 913                             MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb,)
 914             self.shouldFail(AssertionError, 'collective dircap',
 915                             "The URI in '%s' is not a readonly cap to a directory." % os.path.join('private', 'collective_dircap'),
 916                             MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
 917
 918             def _not_implemented():
 919                 raise NotImplementedError("blah")
 920             self.patch(magic_folder, 'get_inotify_module', _not_implemented)
 921             self.shouldFail(NotImplementedError, 'unsupported', 'blah',
 922                             MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
 923         d.addCallback(_check_errors)
 924         return d
 925
 926     def test_write_downloaded_file(self):
 927         workdir = u"cli/MagicFolder/write-downloaded-file"
 928         local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
 929
 930         class TestWriteFileMixin(WriteFileMixin):
 931             def _log(self, msg):
 932                 pass
 933
 934         writefile = TestWriteFileMixin()
 935
 936         # create a file with name "foobar" with content "foo"
 937         # write downloaded file content "bar" into "foobar" with is_conflict = False
 938         fileutil.make_dirs(workdir)
 939         fileutil.write(local_file, "foo")
 940
 941         # if is_conflict is False, then the .conflict file shouldn't exist.
 942         writefile._write_downloaded_file(local_file, "bar", False, None)
 943         conflicted_path = local_file + u".conflict"
 944         self.failIf(os.path.exists(conflicted_path))
 945
 946         # At this point, the backup file should exist with content "foo"
 947         backup_path = local_file + u".backup"
 948         self.failUnless(os.path.exists(backup_path))
 949         self.failUnlessEqual(fileutil.read(backup_path), "foo")
 950
 951         # .tmp file shouldn't exist
 952         self.failIf(os.path.exists(local_file + u".tmp"))
 953
 954         # .. and the original file should have the new content
 955         self.failUnlessEqual(fileutil.read(local_file), "bar")
 956
 957         # now a test for conflicted case
 958         writefile._write_downloaded_file(local_file, "bar", True, None)
 959         self.failUnless(os.path.exists(conflicted_path))
 960
 961         # .tmp file shouldn't exist
 962         self.failIf(os.path.exists(local_file + u".tmp"))
 963
 964
 965 class RealTest(MagicFolderTestMixin, unittest.TestCase):
 966     """This is skipped unless both Twisted and the platform support inotify."""
 967
 968     def setUp(self):
 969         MagicFolderTestMixin.setUp(self)
 970         self.inotify = magic_folder.get_inotify_module()
 971
 972     def notify(self, path, mask, magic=None, flush=True):
 973         # Writing to the filesystem causes the notification.
 974         # However, flushing filesystem buffers may be necessary on Windows.
 975         if flush:
 976             fileutil.flush_volume(path.path)
 977
 978 try:
 979     magic_folder.get_inotify_module()
 980 except NotImplementedError:
 981     RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."