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