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
  24
  25 class MagicFolderTestMixin(MagicFolderCLITestMixin, ShouldFailMixin, ReallyEqualMixin, NonASCIIPathMixin):
  26     """
  27     These tests will be run both with a mock notifier, and (on platforms that support it)
  28     with the real INotify.
  29     """
  30
  31     def setUp(self):
  32         GridTestMixin.setUp(self)
  33         temp = self.mktemp()
  34         self.basedir = abspath_expanduser_unicode(temp.decode(get_filesystem_encoding()))
  35         self.magicfolder = None
  36         self.patch(Downloader, 'REMOTE_SCAN_INTERVAL', 0)
  37
  38     def _get_count(self, name, client=None):
  39         counters = (client or self.get_client()).stats_provider.get_stats()["counters"]
  40         return counters.get('magic_folder.%s' % (name,), 0)
  41
  42     def _createdb(self):
  43         dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.basedir)
  44         mdb = magicfolderdb.get_magicfolderdb(dbfile, create_version=(magicfolderdb.SCHEMA_v1, 1))
  45         self.failUnless(mdb, "unable to create magicfolderdb from %r" % (dbfile,))
  46         self.failUnlessEqual(mdb.VERSION, 1)
  47         return mdb
  48
  49     def _restart_client(self, ign):
  50         #print "_restart_client"
  51         d = self.restart_client()
  52         d.addCallback(self._wait_until_started)
  53         return d
  54
  55     def _wait_until_started(self, ign):
  56         #print "_wait_until_started"
  57         self.magicfolder = self.get_client().getServiceNamed('magic-folder')
  58         return self.magicfolder.ready()
  59
  60     def test_db_basic(self):
  61         fileutil.make_dirs(self.basedir)
  62         self._createdb()
  63
  64     def test_db_persistence(self):
  65         """Test that a file upload creates an entry in the database."""
  66
  67         fileutil.make_dirs(self.basedir)
  68         db = self._createdb()
  69
  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             fileutil.write(abspath_expanduser_unicode(u"what", base=small_tree_dir), "say when")
 157             os.rename(small_tree_dir, new_small_tree_dir)
 158             self.notify(to_filepath(new_small_tree_dir), self.inotify.IN_MOVED_TO)
 159
 160             return DeferredListShouldSucceed([downloaded_d, uploaded_d])
 161         d.addCallback(_check_move_small_tree)
 162         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 163         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 3))
 164         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 1))
 165         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 166         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 167
 168         def _check_moved_tree_is_watched(res):
 169             print "_check_moved_tree_is_watched"
 170             downloaded_d = self.magicfolder.downloader.set_hook('processed', ignore_count=1)
 171             uploaded_d = self.magicfolder.uploader.set_hook('processed')
 172             fileutil.write(abspath_expanduser_unicode(u"another", base=new_small_tree_dir), "file")
 173             self.notify(to_filepath(abspath_expanduser_unicode(u"another", base=new_small_tree_dir)), self.inotify.IN_CLOSE_WRITE)
 174
 175             return DeferredListShouldSucceed([downloaded_d, uploaded_d])
 176         d.addCallback(_check_moved_tree_is_watched)
 177         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 178         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 179         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 180         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 181         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 182
 183         # Files that are moved out of the upload directory should no longer be watched.
 184         #def _move_dir_away(ign):
 185         #    os.rename(new_empty_tree_dir, empty_tree_dir)
 186         #    # Wuh? Why don't we get this event for the real test?
 187         #    #self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_FROM)
 188         #d.addCallback(_move_dir_away)
 189         #def create_file(val):
 190         #    test_file = abspath_expanduser_unicode(u"what", base=empty_tree_dir)
 191         #    fileutil.write(test_file, "meow")
 192         #    #self.notify(...)
 193         #    return
 194         #d.addCallback(create_file)
 195         #d.addCallback(lambda ign: time.sleep(1))  # XXX ICK
 196         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 197         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
 198         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
 199         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 200         #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
 201
 202         d.addBoth(self.cleanup)
 203         return d
 204
 205     def test_persistence(self):
 206         """
 207         Perform an upload of a given file and then stop the client.
 208         Start a new client and magic-folder service... and verify that the file is NOT uploaded
 209         a second time. This test is meant to test the database persistence along with
 210         the startup and shutdown code paths of the magic-folder service.
 211         """
 212         self.set_up_grid()
 213         self.local_dir = abspath_expanduser_unicode(u"test_persistence", base=self.basedir)
 214         self.mkdir_nonascii(self.local_dir)
 215         self.collective_dircap = ""
 216
 217         d = defer.succeed(None)
 218         d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
 219         d.addCallback(self._restart_client)
 220
 221         def create_test_file(filename):
 222             d2 = self.magicfolder.uploader.set_hook('processed')
 223             test_file = abspath_expanduser_unicode(filename, base=self.local_dir)
 224             fileutil.write(test_file, "meow %s" % filename)
 225             self.notify(to_filepath(test_file), self.inotify.IN_CLOSE_WRITE)
 226             return d2
 227         d.addCallback(lambda ign: create_test_file(u"what1"))
 228         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 229         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 230         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 231         d.addCallback(self.cleanup)
 232
 233         d.addCallback(self._restart_client)
 234         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 235         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
 236         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 237         d.addCallback(lambda ign: create_test_file(u"what2"))
 238         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 239         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 2))
 240         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 241         d.addBoth(self.cleanup)
 242         return d
 243
 244     def test_magic_folder(self):
 245         self.set_up_grid()
 246         self.local_dir = os.path.join(self.basedir, self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir"))
 247         self.mkdir_nonascii(self.local_dir)
 248
 249         d = self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
 250         d.addCallback(self._restart_client)
 251
 252         # Write something short enough for a LIT file.
 253         d.addCallback(lambda ign: self._check_file(u"short", "test"))
 254
 255         # Write to the same file again with different data.
 256         d.addCallback(lambda ign: self._check_file(u"short", "different"))
 257
 258         # Test that temporary files are not uploaded.
 259         d.addCallback(lambda ign: self._check_file(u"tempfile", "test", temporary=True))
 260
 261         # Test creation of a subdirectory.
 262         d.addCallback(lambda ign: self._check_mkdir(u"directory"))
 263
 264         # Write something longer, and also try to test a Unicode name if the fs can represent it.
 265         name_u = self.unicode_or_fallback(u"l\u00F8ng", u"long")
 266         d.addCallback(lambda ign: self._check_file(name_u, "test"*100))
 267
 268         # TODO: test that causes an upload failure.
 269         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 270
 271         d.addBoth(self.cleanup)
 272         return d
 273
 274     def _check_mkdir(self, name_u):
 275         return self._check_file(name_u + u"/", "", directory=True)
 276
 277     def _check_file(self, name_u, data, temporary=False, directory=False):
 278         precondition(not (temporary and directory), temporary=temporary, directory=directory)
 279
 280         previously_uploaded = self._get_count('uploader.objects_succeeded')
 281         previously_disappeared = self._get_count('uploader.objects_disappeared')
 282
 283         d = self.magicfolder.uploader.set_hook('processed')
 284
 285         path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
 286         path = to_filepath(path_u)
 287
 288         if directory:
 289             os.mkdir(path_u)
 290             event_mask = self.inotify.IN_CREATE | self.inotify.IN_ISDIR
 291         else:
 292             # We don't use FilePath.setContent() here because it creates a temporary file that
 293             # is renamed into place, which causes events that the test is not expecting.
 294             f = open(path_u, "wb")
 295             try:
 296                 if temporary and sys.platform != "win32":
 297                     os.unlink(path_u)
 298                 f.write(data)
 299             finally:
 300                 f.close()
 301             if temporary and sys.platform == "win32":
 302                 os.unlink(path_u)
 303                 self.notify(path, self.inotify.IN_DELETE)
 304             event_mask = self.inotify.IN_CLOSE_WRITE
 305
 306         fileutil.flush_volume(path_u)
 307         self.notify(path, event_mask)
 308         encoded_name_u = magicpath.path2magic(name_u)
 309
 310         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
 311         if temporary:
 312             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
 313                                                                  previously_disappeared + 1))
 314         else:
 315             d.addCallback(lambda ign: self.upload_dirnode.get(encoded_name_u))
 316             d.addCallback(download_to_data)
 317             d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
 318             d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
 319                                                                  previously_uploaded + 1))
 320
 321         d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
 322         return d
 323
 324     def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
 325         encoded_name_u = magicpath.path2magic(relpath_u)
 326         d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
 327         def check_latest(result):
 328             if result[0] is not None:
 329                 node, metadata = result
 330                 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
 331         d.addCallback(check_latest)
 332         return d
 333
 334     def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
 335         version = magicfolder._db.get_local_file_version(relpath_u)
 336         #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
 337         self.failUnlessEqual(version, expected_version)
 338
 339     def test_alice_bob(self):
 340         alice_clock = task.Clock()
 341         bob_clock = task.Clock()
 342         d = self.setup_alice_and_bob(alice_clock, bob_clock)
 343         def get_results(result):
 344             # XXX are these used?
 345             (self.alice_collective_dircap, self.alice_upload_dircap, self.alice_magicfolder,
 346              self.bob_collective_dircap,   self.bob_upload_dircap,   self.bob_magicfolder) = result
 347             #print "Alice magicfolderdb is at %r" % (self.alice_magicfolder._client.basedir)
 348             #print "Bob   magicfolderdb is at %r" % (self.bob_magicfolder._client.basedir)
 349         d.addCallback(get_results)
 350
 351         def _check_uploader_count(ign, name, expected):
 352             self.failUnlessReallyEqual(self._get_count('uploader.'+name, client=self.alice_magicfolder._client),
 353                                        expected)
 354         def _check_downloader_count(ign, name, expected):
 355             self.failUnlessReallyEqual(self._get_count('downloader.'+name, client=self.bob_magicfolder._client),
 356                                        expected)
 357
 358         def _wait_for(ign, something_to_do):
 359             downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
 360             uploaded_d = self.alice_magicfolder.uploader.set_hook('processed')
 361             something_to_do()
 362             print "Waiting for Alice to upload\n"
 363             alice_clock.advance(0)
 364             def _wait_for_Bob(ign):
 365                 print "Now waiting for Bob to download\n"
 366                 bob_clock.advance(0)
 367                 return downloaded_d
 368             uploaded_d.addCallback(_wait_for_Bob)
 369             return uploaded_d
 370
 371         def Alice_to_write_a_file():
 372             print "Alice writes a file\n"
 373             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 374             fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
 375             self.magicfolder = self.alice_magicfolder
 376             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 377         d.addCallback(_wait_for, Alice_to_write_a_file)
 378
 379         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
 380         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
 381         d.addCallback(_check_uploader_count, 'objects_failed', 0)
 382         d.addCallback(_check_uploader_count, 'objects_succeeded', 1)
 383         d.addCallback(_check_uploader_count, 'files_uploaded', 1)
 384         d.addCallback(_check_uploader_count, 'objects_queued', 0)
 385         d.addCallback(_check_uploader_count, 'directories_created', 0)
 386
 387         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
 388         d.addCallback(_check_downloader_count, 'objects_failed', 0)
 389         d.addCallback(_check_downloader_count, 'objects_downloaded', 1)
 390
 391         def Alice_to_delete_file():
 392             print "Alice deletes the file!\n"
 393             os.unlink(self.file_path)
 394             self.magicfolder = self.alice_magicfolder
 395             self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE)
 396         d.addCallback(_wait_for, Alice_to_delete_file)
 397
 398         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
 399         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
 400         d.addCallback(_check_uploader_count, 'objects_failed', 0)
 401         d.addCallback(_check_uploader_count, 'objects_succeeded', 2)
 402
 403         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
 404         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
 405         d.addCallback(_check_downloader_count, 'objects_failed', 0)
 406         d.addCallback(_check_downloader_count, 'objects_downloaded', 2)
 407
 408         def Alice_to_rewrite_file():
 409             print "Alice rewrites file\n"
 410             self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
 411             fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
 412             self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
 413         d.addCallback(_wait_for, Alice_to_rewrite_file)
 414
 415         d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
 416         d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
 417         d.addCallback(_check_uploader_count, 'objects_failed', 0)
 418         d.addCallback(_check_uploader_count, 'objects_succeeded', 3)
 419         d.addCallback(_check_uploader_count, 'files_uploaded', 3)
 420         d.addCallback(_check_uploader_count, 'objects_queued', 0)
 421         d.addCallback(_check_uploader_count, 'directories_created', 0)
 422
 423         d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 2))
 424         d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 2))
 425         d.addCallback(_check_downloader_count, 'objects_failed', 0)
 426         d.addCallback(_check_downloader_count, 'objects_downloaded', 3)
 427
 428         def _cleanup(ign, magicfolder, clock):
 429             d2 = magicfolder.finish()
 430             clock.advance(0)
 431             return d2
 432
 433         def cleanup_Alice_and_Bob(result):
 434             print "cleanup alice bob test\n"
 435             d = defer.succeed(None)
 436             d.addCallback(_cleanup, self.alice_magicfolder, alice_clock)
 437             d.addCallback(_cleanup, self.bob_magicfolder, bob_clock)
 438             d.addCallback(lambda ign: result)
 439             return d
 440         d.addBoth(cleanup_Alice_and_Bob)
 441         return d
 442
 443
 444 class MockTest(MagicFolderTestMixin, unittest.TestCase):
 445     """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
 446
 447     def setUp(self):
 448         MagicFolderTestMixin.setUp(self)
 449         self.inotify = fake_inotify
 450         self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
 451
 452     def notify(self, path, mask):
 453         self.magicfolder.uploader._notifier.event(path, mask)
 454
 455     def test_errors(self):
 456         self.set_up_grid()
 457
 458         errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
 459         os.mkdir(errors_dir)
 460         not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
 461         fileutil.write(not_a_dir, "")
 462         magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
 463         doesnotexist  = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
 464
 465         client = self.g.clients[0]
 466         d = client.create_dirnode()
 467         def _check_errors(n):
 468             self.failUnless(IDirectoryNode.providedBy(n))
 469             upload_dircap = n.get_uri()
 470             readonly_dircap = n.get_readonly_uri()
 471
 472             self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
 473                             MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
 474             self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
 475                             MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
 476             self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
 477                             MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
 478             self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
 479                             MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
 480             self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
 481                             MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb,)
 482             self.shouldFail(AssertionError, 'collective dircap',
 483                             "The URI in 'private/collective_dircap' is not a readonly cap to a directory.",
 484                             MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
 485
 486             def _not_implemented():
 487                 raise NotImplementedError("blah")
 488             self.patch(magic_folder, 'get_inotify_module', _not_implemented)
 489             self.shouldFail(NotImplementedError, 'unsupported', 'blah',
 490                             MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
 491         d.addCallback(_check_errors)
 492         return d
 493
 494     def test_write_downloaded_file(self):
 495         workdir = u"cli/MagicFolder/write-downloaded-file"
 496         local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
 497
 498         class TestWriteFileMixin(WriteFileMixin):
 499             def _log(self, msg):
 500                 pass
 501
 502         writefile = TestWriteFileMixin()
 503
 504         # create a file with name "foobar" with content "foo"
 505         # write downloaded file content "bar" into "foobar" with is_conflict = False
 506         fileutil.make_dirs(workdir)
 507         fileutil.write(local_file, "foo")
 508
 509         # if is_conflict is False, then the .conflict file shouldn't exist.
 510         writefile._write_downloaded_file(local_file, "bar", False, None)
 511         conflicted_path = local_file + u".conflict"
 512         self.failIf(os.path.exists(conflicted_path))
 513
 514         # At this point, the backup file should exist with content "foo"
 515         backup_path = local_file + u".backup"
 516         self.failUnless(os.path.exists(backup_path))
 517         self.failUnlessEqual(fileutil.read(backup_path), "foo")
 518
 519         # .tmp file shouldn't exist
 520         self.failIf(os.path.exists(local_file + u".tmp"))
 521
 522         # .. and the original file should have the new content
 523         self.failUnlessEqual(fileutil.read(local_file), "bar")
 524
 525         # now a test for conflicted case
 526         writefile._write_downloaded_file(local_file, "bar", True, None)
 527         self.failUnless(os.path.exists(conflicted_path))
 528
 529         # .tmp file shouldn't exist
 530         self.failIf(os.path.exists(local_file + u".tmp"))
 531
 532
 533 class RealTest(MagicFolderTestMixin, unittest.TestCase):
 534     """This is skipped unless both Twisted and the platform support inotify."""
 535
 536     def setUp(self):
 537         MagicFolderTestMixin.setUp(self)
 538         self.inotify = magic_folder.get_inotify_module()
 539
 540     def notify(self, path, mask):
 541         # Writing to the filesystem causes the notification.
 542         pass
 543
 544 try:
 545     magic_folder.get_inotify_module()
 546 except NotImplementedError:
 547     RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."