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
   6
   7 from allmydata.interfaces import IDirectoryNode
   8
   9 from allmydata.util import fake_inotify, fileutil
  10 from allmydata.util.encodingutil import get_filesystem_encoding, to_filepath
  11 from allmydata.util.consumer import download_to_data
  12 from allmydata.test.no_network import GridTestMixin
  13 from allmydata.test.common_util import ReallyEqualMixin, NonASCIIPathMixin
  14 from allmydata.test.common import ShouldFailMixin
  15 from .test_cli_magic_folder import MagicFolderCLITestMixin
  16
  17 from allmydata.frontends import magic_folder
  18 from allmydata.frontends.magic_folder import MagicFolder, Downloader
  19 from allmydata import backupdb, magicpath
  20 from allmydata.util.fileutil import abspath_expanduser_unicode
  21
  22
  23 class MagicFolderTestMixin(MagicFolderCLITestMixin, ShouldFailMixin, ReallyEqualMixin, NonASCIIPathMixin):
  24     """
  25     These tests will be run both with a mock notifier, and (on platforms that support it)
  26     with the real INotify.
  27     """
  28
  29     def setUp(self):
  30         GridTestMixin.setUp(self)
  31         temp = self.mktemp()
  32         self.basedir = abspath_expanduser_unicode(temp.decode(get_filesystem_encoding()))
  33         self.magicfolder = None
  34
  35     def _get_count(self, name, client=None):
  36         counters = (client or self.get_client()).stats_provider.get_stats()["counters"]
  37         return counters.get('magic_folder.%s' % (name,), 0)
  38
  39     def _createdb(self):
  40         dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.basedir)
  41         bdb = backupdb.get_backupdb(dbfile, create_version=(backupdb.SCHEMA_v3, 3))
  42         self.failUnless(bdb, "unable to create backupdb from %r" % (dbfile,))
  43         self.failUnlessEqual(bdb.VERSION, 3)
  44         return bdb
  45
  46     def _restart_client(self, ign):
  47         #print "_restart_client"
  48         d = self.restart_client()
  49         d.addCallback(self._wait_until_started)
  50         return d
  51
  52     def _wait_until_started(self, ign):
  53         #print "_wait_until_started"
  54         self.magicfolder = self.get_client().getServiceNamed('magic-folder')
  55         return self.magicfolder.ready()
  56
  57     def test_db_basic(self):
  58         fileutil.make_dirs(self.basedir)
  59         self._createdb()
  60
  61     def test_db_persistence(self):
  62         """Test that a file upload creates an entry in the database."""
  63
  64         fileutil.make_dirs(self.basedir)
  65         db = self._createdb()
  66
  67         relpath1 = u"myFile1"
  68         pathinfo = fileutil.PathInfo(isdir=False, isfile=True, islink=False,
  69                                      exists=True, size=1, mtime=123, ctime=456)
  70         db.did_upload_version('URI:LIT:1', relpath1, 0, pathinfo)
  71
  72         c = db.cursor
  73         c.execute("SELECT size, mtime, ctime"
  74                   " FROM local_files"
  75                   " WHERE path=?",
  76                   (relpath1,))
  77         row = c.fetchone()
  78         self.failUnlessEqual(row, (pathinfo.size, pathinfo.mtime, pathinfo.ctime))
  79
  80         # Second test uses db.is_new_file instead of SQL query directly
  81         # to confirm the previous upload entry in the db.
  82         relpath2 = u"myFile2"
  83         path2 = os.path.join(self.basedir, relpath2)
  84         fileutil.write(path2, "meow\n")
  85         pathinfo = fileutil.get_pathinfo(path2)
  86         db.did_upload_version('URI:LIT:2', relpath2, 0, pathinfo)
  87         self.failUnlessFalse(db.is_new_file(pathinfo, relpath2))
  88
  89         different_pathinfo = fileutil.PathInfo(isdir=False, isfile=True, islink=False,
  90                                                exists=True, size=0, mtime=pathinfo.mtime, ctime=pathinfo.ctime)
  91         self.failUnlessTrue(db.is_new_file(different_pathinfo, relpath2))
  92
  93     def test_magicfolder_start_service(self):
  94         self.set_up_grid()
  95
  96         self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
  97                                                     base=self.basedir)
  98         self.mkdir_nonascii(self.local_dir)
  99
 100         d = defer.succeed(None)
 101         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 0))
 102
 103         d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
 104         d.addCallback(self._restart_client)
 105
 106         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 1))
 107         d.addBoth(self.cleanup)
 108         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 0))
 109         return d
 110
 111     def test_move_tree(self):
 112         self.set_up_grid()
 113
 114         self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
 115                                                     base=self.basedir)
 116         self.mkdir_nonascii(self.local_dir)
 117
 118         empty_tree_name = self.unicode_or_fallback(u"empty_tr\u00EAe", u"empty_tree")
 119         empty_tree_dir = abspath_expanduser_unicode(empty_tree_name, base=self.basedir)
 120         new_empty_tree_dir = abspath_expanduser_unicode(empty_tree_name, base=self.local_dir)
 121
 122         small_tree_name = self.unicode_or_fallback(u"small_tr\u00EAe", u"empty_tree")
 123         small_tree_dir = abspath_expanduser_unicode(small_tree_name, base=self.basedir)
 124         new_small_tree_dir = abspath_expanduser_unicode(small_tree_name, base=self.local_dir)
 125
 126         d = self.create_invite_join_magic_folder(u"Alice", self.local_dir)
 127         d.addCallback(self._restart_client)
 128
 129         def _check_move_empty_tree(res):
 130             #print "_check_move_empty_tree"
 131             self.mkdir_nonascii(empty_tree_dir)
 132             d2 = self.magicfolder.uploader.set_hook('processed')
 133             os.rename(empty_tree_dir, new_empty_tree_dir)
 134             self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_TO)
 135             return d2
 136         d.addCallback(_check_move_empty_tree)
 137         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 138         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 139         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 0))
 140         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 141         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 1))
 142
 143         def _check_move_small_tree(res):
 144             #print "_check_move_small_tree"
 145             self.mkdir_nonascii(small_tree_dir)
 146             fileutil.write(abspath_expanduser_unicode(u"what", base=small_tree_dir), "say when")
 147             d2 = self.magicfolder.uploader.set_hook('processed', ignore_count=1)
 148             os.rename(small_tree_dir, new_small_tree_dir)
 149             self.notify(to_filepath(new_small_tree_dir), self.inotify.IN_MOVED_TO)
 150             return d2
 151         d.addCallback(_check_move_small_tree)
 152         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 153         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 3))
 154         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 1))
 155         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 156         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 157
 158         def _check_moved_tree_is_watched(res):
 159             #print "_check_moved_tree_is_watched"
 160             d2 = self.magicfolder.uploader.set_hook('processed')
 161             fileutil.write(abspath_expanduser_unicode(u"another", base=new_small_tree_dir), "file")
 162             self.notify(to_filepath(abspath_expanduser_unicode(u"another", base=new_small_tree_dir)), self.inotify.IN_CLOSE_WRITE)
 163             return d2
 164         d.addCallback(_check_moved_tree_is_watched)
 165         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 166         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 167         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 168         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 169         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 170
 171         # Files that are moved out of the upload directory should no longer be watched.
 172         #def _move_dir_away(ign):
 173         #    os.rename(new_empty_tree_dir, empty_tree_dir)
 174         #    # Wuh? Why don't we get this event for the real test?
 175         #    #self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_FROM)
 176         #d.addCallback(_move_dir_away)
 177         #def create_file(val):
 178         #    test_file = abspath_expanduser_unicode(u"what", base=empty_tree_dir)
 179         #    fileutil.write(test_file, "meow")
 180         #    #self.notify(...)
 181         #    return
 182         #d.addCallback(create_file)
 183         #d.addCallback(lambda ign: time.sleep(1))  # XXX ICK
 184         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 185         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 186         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 187         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 188         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 189
 190         d.addBoth(self.cleanup)
 191         return d
 192
 193     def test_persistence(self):
 194         """
 195         Perform an upload of a given file and then stop the client.
 196         Start a new client and magic-folder service... and verify that the file is NOT uploaded
 197         a second time. This test is meant to test the database persistence along with
 198         the startup and shutdown code paths of the magic-folder service.
 199         """
 200         self.set_up_grid()
 201         self.local_dir = abspath_expanduser_unicode(u"test_persistence", base=self.basedir)
 202         self.mkdir_nonascii(self.local_dir)
 203         self.collective_dircap = ""
 204
 205         d = defer.succeed(None)
 206         d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
 207         d.addCallback(self._restart_client)
 208
 209         def create_test_file(filename):
 210             d2 = self.magicfolder.uploader.set_hook('processed')
 211             test_file = abspath_expanduser_unicode(filename, base=self.local_dir)
 212             fileutil.write(test_file, "meow %s" % filename)
 213             self.notify(to_filepath(test_file), self.inotify.IN_CLOSE_WRITE)
 214             return d2
 215         d.addCallback(lambda ign: create_test_file(u"what1"))
 216         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 217         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 218         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 219         d.addCallback(self.cleanup)
 220
 221         d.addCallback(self._restart_client)
 222         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 223         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 224         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 225         d.addCallback(lambda ign: create_test_file(u"what2"))
 226         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 227         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 2))
 228         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 229         d.addBoth(self.cleanup)
 230         return d
 231
 232     def test_magic_folder(self):
 233         self.set_up_grid()
 234         self.local_dir = os.path.join(self.basedir, self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir"))
 235         self.mkdir_nonascii(self.local_dir)
 236
 237         d = self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
 238         d.addCallback(self._restart_client)
 239
 240         # Write something short enough for a LIT file.
 241         d.addCallback(lambda ign: self._check_file(u"short", "test"))
 242
 243         # Write to the same file again with different data.
 244         d.addCallback(lambda ign: self._check_file(u"short", "different"))
 245
 246         # Test that temporary files are not uploaded.
 247         d.addCallback(lambda ign: self._check_file(u"tempfile", "test", temporary=True))
 248
 249         # Test that we tolerate creation of a subdirectory.
 250         d.addCallback(lambda ign: os.mkdir(os.path.join(self.local_dir, u"directory")))
 251
 252         # Write something longer, and also try to test a Unicode name if the fs can represent it.
 253         name_u = self.unicode_or_fallback(u"l\u00F8ng", u"long")
 254         d.addCallback(lambda ign: self._check_file(name_u, "test"*100))
 255
 256         # TODO: test that causes an upload failure.
 257         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 258
 259         d.addBoth(self.cleanup)
 260         return d
 261
 262     def _check_file(self, name_u, data, temporary=False):
 263         previously_uploaded = self._get_count('uploader.objects_succeeded')
 264         previously_disappeared = self._get_count('uploader.objects_disappeared')
 265
 266         d = self.magicfolder.uploader.set_hook('processed')
 267
 268         path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
 269         path = to_filepath(path_u)
 270
 271         # We don't use FilePath.setContent() here because it creates a temporary file that
 272         # is renamed into place, which causes events that the test is not expecting.
 273         f = open(path_u, "wb")
 274         try:
 275             if temporary and sys.platform != "win32":
 276                 os.unlink(path_u)
 277             f.write(data)
 278         finally:
 279             f.close()
 280         if temporary and sys.platform == "win32":
 281             os.unlink(path_u)
 282             self.notify(path, self.inotify.IN_DELETE)
 283         fileutil.flush_volume(path_u)
 284         self.notify(path, self.inotify.IN_CLOSE_WRITE)
 285
 286         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 287         if temporary:
 288             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
 289                                                                  previously_disappeared + 1))
 290         else:
 291             d.addCallback(lambda ign: self.upload_dirnode.get(name_u))
 292             d.addCallback(download_to_data)
 293             d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
 294             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
 295                                                                  previously_uploaded + 1))
 296
 297         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 298         return d
 299
 300     def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
 301         encoded_name_u = magicpath.path2magic(relpath_u)
 302         d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
 303         def check_latest(result):
 304             if result[0] is not None:
 305                 node, metadata = result
 306                 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
 307         d.addCallback(check_latest)
 308         return d
 309
 310     def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
 311         version = magicfolder._db.get_local_file_version(relpath_u)
 312         #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
 313         self.failUnlessEqual(version, expected_version)
 314
 315     def test_alice_bob(self):
 316         d = self.setup_alice_and_bob()
 317         def get_results(result):
 318             # XXX are these used?
 319             (self.alice_collective_dircap, self.alice_upload_dircap, self.alice_magicfolder,
 320              self.bob_collective_dircap,   self.bob_upload_dircap,   self.bob_magicfolder) = result
 321             #print "Alice magicfolderdb is at %r" % (self.alice_magicfolder._client.basedir)
 322             #print "Bob   magicfolderdb is at %r" % (self.bob_magicfolder._client.basedir)
 323         d.addCallback(get_results)
 324
 325         def Alice_write_a_file(result):
 326             print "Alice writes a file\n"
 327             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 328             fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
 329             self.magicfolder = self.alice_magicfolder
 330             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 331
 332         d.addCallback(Alice_write_a_file)
 333
 334         def Alice_wait_for_upload(result):
 335             print "Alice waits for an upload\n"
 336             d2 = self.alice_magicfolder.uploader.set_hook('processed')
 337             return d2
 338         d.addCallback(Alice_wait_for_upload)
 339         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
 340         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
 341
 342         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 343         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded', client=self.alice_magicfolder._client), 1))
 344         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded', client=self.alice_magicfolder._client), 1))
 345         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued', client=self.alice_magicfolder._client), 0))
 346         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created', client=self.alice_magicfolder._client), 0))
 347
 348         def Bob_wait_for_download(result):
 349             print "Bob waits for a download\n"
 350             d2 = self.bob_magicfolder.downloader.set_hook('processed')
 351             return d2
 352         d.addCallback(Bob_wait_for_download)
 353         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
 354         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 0)) # XXX prolly not needed
 355         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_failed'), 0))
 356         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client), 1))
 357
 358
 359         # test deletion of file behavior
 360         def Alice_delete_file(result):
 361             print "Alice deletes the file!\n"
 362             os.unlink(self.file_path)
 363             self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE)
 364
 365             return None
 366         d.addCallback(Alice_delete_file)
 367         d.addCallback(Alice_wait_for_upload)
 368         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 369         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded', client=self.alice_magicfolder._client), 2))
 370         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
 371         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
 372
 373         d.addCallback(Bob_wait_for_download)
 374         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_failed'), 0))
 375         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client), 2))
 376         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
 377         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
 378
 379         def Alice_rewrite_file(result):
 380             print "Alice rewrites file\n"
 381             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 382             fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
 383             self.magicfolder = self.alice_magicfolder
 384             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 385
 386         d.addCallback(Alice_rewrite_file)
 387         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
 388         d.addCallback(Alice_wait_for_upload)
 389
 390         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
 391         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
 392
 393         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 394         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded', client=self.alice_magicfolder._client), 3))
 395         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded', client=self.alice_magicfolder._client), 3))
 396         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued', client=self.alice_magicfolder._client), 0))
 397         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created', client=self.alice_magicfolder._client), 0))
 398
 399         d.addCallback(Bob_wait_for_download)
 400         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 2))
 401         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 2))
 402         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_failed'), 0))
 403         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client), 3))
 404
 405         def cleanup_Alice_and_Bob(result):
 406             print "cleanup alice bob test\n"
 407             d = defer.succeed(None)
 408             d.addCallback(lambda ign: self.alice_magicfolder.finish())
 409             d.addCallback(lambda ign: self.bob_magicfolder.finish())
 410             d.addCallback(lambda ign: result)
 411             return d
 412         d.addCallback(cleanup_Alice_and_Bob)
 413         return d
 414
 415 class MockTest(MagicFolderTestMixin, unittest.TestCase):
 416     """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
 417
 418     def setUp(self):
 419         MagicFolderTestMixin.setUp(self)
 420         self.inotify = fake_inotify
 421         self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
 422
 423     def notify(self, path, mask):
 424         self.magicfolder.uploader._notifier.event(path, mask)
 425
 426     def test_errors(self):
 427         self.set_up_grid()
 428
 429         errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
 430         os.mkdir(errors_dir)
 431         not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
 432         fileutil.write(not_a_dir, "")
 433         magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
 434         doesnotexist  = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
 435
 436         client = self.g.clients[0]
 437         d = client.create_dirnode()
 438         def _check_errors(n):
 439             self.failUnless(IDirectoryNode.providedBy(n))
 440             upload_dircap = n.get_uri()
 441             readonly_dircap = n.get_readonly_uri()
 442
 443             self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
 444                             MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
 445             self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
 446                             MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
 447             self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
 448                             MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
 449             self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
 450                             MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
 451             self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
 452                             MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb,)
 453             self.shouldFail(AssertionError, 'collective dircap',
 454                             "The URI in 'private/collective_dircap' is not a readonly cap to a directory.",
 455                             MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
 456
 457             def _not_implemented():
 458                 raise NotImplementedError("blah")
 459             self.patch(magic_folder, 'get_inotify_module', _not_implemented)
 460             self.shouldFail(NotImplementedError, 'unsupported', 'blah',
 461                             MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
 462         d.addCallback(_check_errors)
 463         return d
 464
 465     def test_write_downloaded_file(self):
 466         workdir = u"cli/MagicFolder/write-downloaded-file"
 467         local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
 468
 469         # create a file with name "foobar" with content "foo"
 470         # write downloaded file content "bar" into "foobar" with is_conflict = False
 471         fileutil.make_dirs(workdir)
 472         fileutil.write(local_file, "foo")
 473
 474         # if is_conflict is False, then the .conflict file shouldn't exist.
 475         Downloader._write_downloaded_file(local_file, "bar", False, None)
 476         conflicted_path = local_file + u".conflict"
 477         self.failIf(os.path.exists(conflicted_path))
 478
 479         # At this point, the backup file should exist with content "foo"
 480         backup_path = local_file + u".backup"
 481         self.failUnless(os.path.exists(backup_path))
 482         self.failUnlessEqual(fileutil.read(backup_path), "foo")
 483
 484         # .tmp file shouldn't exist
 485         self.failIf(os.path.exists(local_file + u".tmp"))
 486
 487         # .. and the original file should have the new content
 488         self.failUnlessEqual(fileutil.read(local_file), "bar")
 489
 490         # now a test for conflicted case
 491         Downloader._write_downloaded_file(local_file, "bar", True, None)
 492         self.failUnless(os.path.exists(conflicted_path))
 493
 494         # .tmp file shouldn't exist
 495         self.failIf(os.path.exists(local_file + u".tmp"))
 496
 497
 498 class RealTest(MagicFolderTestMixin, unittest.TestCase):
 499     """This is skipped unless both Twisted and the platform support inotify."""
 500
 501     def setUp(self):
 502         MagicFolderTestMixin.setUp(self)
 503         self.inotify = magic_folder.get_inotify_module()
 504
 505     def notify(self, path, mask):
 506         # Writing to the filesystem causes the notification.
 507         pass
 508
 509 try:
 510     magic_folder.get_inotify_module()
 511 except NotImplementedError:
 512     RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."