4 from twisted.trial import unittest
5 from twisted.internet import defer, task
7 from allmydata.interfaces import IDirectoryNode
8 from allmydata.util.assertutil import precondition
10 from allmydata.util import fake_inotify, fileutil
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
18 from allmydata.frontends import magic_folder
19 from allmydata.frontends.magic_folder import MagicFolder, Downloader, WriteFileMixin
20 from allmydata import magicfolderdb, magicpath
21 from allmydata.util.fileutil import abspath_expanduser_unicode
22 from allmydata.immutable.upload import Data
25 class MagicFolderTestMixin(MagicFolderCLITestMixin, ShouldFailMixin, ReallyEqualMixin, NonASCIIPathMixin):
27 These tests will be run both with a mock notifier, and (on platforms that support it)
28 with the real INotify.
32 GridTestMixin.setUp(self)
34 self.basedir = abspath_expanduser_unicode(temp.decode(get_filesystem_encoding()))
35 self.magicfolder = None
36 self.patch(Downloader, 'REMOTE_SCAN_INTERVAL', 0)
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)
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)
49 def _restart_client(self, ign):
50 #print "_restart_client"
51 d = self.restart_client()
52 d.addCallback(self._wait_until_started)
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()
60 def test_db_basic(self):
61 fileutil.make_dirs(self.basedir)
64 def test_db_persistence(self):
65 """Test that a file upload creates an entry in the database."""
67 fileutil.make_dirs(self.basedir)
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)
76 c.execute("SELECT size, mtime, ctime"
81 self.failUnlessEqual(row, (pathinfo.size, pathinfo.mtime, pathinfo.ctime))
83 # Second test uses db.is_new_file instead of SQL query directly
84 # to confirm the previous upload entry in the db.
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))
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))
96 def test_magicfolder_start_service(self):
99 self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
101 self.mkdir_nonascii(self.local_dir)
103 d = defer.succeed(None)
104 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.dirs_monitored'), 0))
106 d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
107 d.addCallback(self._restart_client)
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))
114 def test_move_tree(self):
117 self.local_dir = abspath_expanduser_unicode(self.unicode_or_fallback(u"l\u00F8cal_dir", u"local_dir"),
119 self.mkdir_nonascii(self.local_dir)
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)
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)
129 d = self.create_invite_join_magic_folder(u"Alice", self.local_dir)
130 d.addCallback(self._restart_client)
132 def _check_move_empty_tree(res):
133 print "_check_move_empty_tree"
134 uploaded_d = self.magicfolder.uploader.set_hook('processed')
135 self.mkdir_nonascii(empty_tree_dir)
136 os.rename(empty_tree_dir, new_empty_tree_dir)
137 self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_TO)
140 d.addCallback(_check_move_empty_tree)
141 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
142 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
143 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 0))
144 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
145 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 1))
147 def _check_move_small_tree(res):
148 print "_check_move_small_tree"
149 uploaded_d = self.magicfolder.uploader.set_hook('processed', ignore_count=1)
150 self.mkdir_nonascii(small_tree_dir)
151 what_path = abspath_expanduser_unicode(u"what", base=small_tree_dir)
152 fileutil.write(what_path, "say when")
153 os.rename(small_tree_dir, new_small_tree_dir)
154 self.notify(to_filepath(new_small_tree_dir), self.inotify.IN_MOVED_TO)
157 d.addCallback(_check_move_small_tree)
158 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
159 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 3))
160 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 1))
161 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
162 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
164 def _check_moved_tree_is_watched(res):
165 print "_check_moved_tree_is_watched"
166 uploaded_d = self.magicfolder.uploader.set_hook('processed')
167 another_path = abspath_expanduser_unicode(u"another", base=new_small_tree_dir)
168 fileutil.write(another_path, "file")
169 self.notify(to_filepath(another_path), self.inotify.IN_CLOSE_WRITE)
172 d.addCallback(_check_moved_tree_is_watched)
173 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
174 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
175 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
176 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
177 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
179 # Files that are moved out of the upload directory should no longer be watched.
180 #def _move_dir_away(ign):
181 # os.rename(new_empty_tree_dir, empty_tree_dir)
182 # # Wuh? Why don't we get this event for the real test?
183 # #self.notify(to_filepath(new_empty_tree_dir), self.inotify.IN_MOVED_FROM)
184 #d.addCallback(_move_dir_away)
185 #def create_file(val):
186 # test_file = abspath_expanduser_unicode(u"what", base=empty_tree_dir)
187 # fileutil.write(test_file, "meow")
190 #d.addCallback(create_file)
191 #d.addCallback(lambda ign: time.sleep(1)) # XXX ICK
192 #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
193 #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 4))
194 #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.files_uploaded'), 2))
195 #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
196 #d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.directories_created'), 2))
198 d.addBoth(self.cleanup)
201 def test_persistence(self):
203 Perform an upload of a given file and then stop the client.
204 Start a new client and magic-folder service... and verify that the file is NOT uploaded
205 a second time. This test is meant to test the database persistence along with
206 the startup and shutdown code paths of the magic-folder service.
209 self.local_dir = abspath_expanduser_unicode(u"test_persistence", base=self.basedir)
210 self.mkdir_nonascii(self.local_dir)
211 self.collective_dircap = ""
213 d = defer.succeed(None)
214 d.addCallback(lambda ign: self.create_invite_join_magic_folder(u"Alice", self.local_dir))
215 d.addCallback(self._restart_client)
217 def create_test_file(filename):
218 d2 = self.magicfolder.uploader.set_hook('processed')
219 test_file = abspath_expanduser_unicode(filename, base=self.local_dir)
220 fileutil.write(test_file, "meow %s" % filename)
221 self.notify(to_filepath(test_file), self.inotify.IN_CLOSE_WRITE)
223 d.addCallback(lambda ign: create_test_file(u"what1"))
224 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
225 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'), 1))
226 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
227 d.addCallback(self.cleanup)
229 d.addCallback(self._restart_client)
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(lambda ign: create_test_file(u"what2"))
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'), 2))
236 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
237 d.addBoth(self.cleanup)
240 @defer.inlineCallbacks
241 def test_delete(self):
243 self.local_dir = os.path.join(self.basedir, u"local_dir")
244 self.mkdir_nonascii(self.local_dir)
246 yield self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
247 yield self._restart_client(None)
251 up_proc = self.magicfolder.uploader.set_hook('processed')
252 # down_proc = self.magicfolder.downloader.set_hook('processed')
253 path = os.path.join(self.local_dir, u'foo')
254 fileutil.write(path, 'foo\n')
255 self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
257 self.assertTrue(os.path.exists(path))
259 # the real test part: delete the file
260 up_proc = self.magicfolder.uploader.set_hook('processed')
262 self.notify(to_filepath(path), self.inotify.IN_DELETE)
264 self.assertFalse(os.path.exists(path))
266 # ensure we still have a DB entry, and that the version is 1
267 node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
268 self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
269 self.failUnlessEqual(metadata['version'], 1)
272 yield self.cleanup(None)
274 @defer.inlineCallbacks
275 def test_delete_and_restore(self):
277 self.local_dir = os.path.join(self.basedir, u"local_dir")
278 self.mkdir_nonascii(self.local_dir)
280 yield self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
281 yield self._restart_client(None)
285 up_proc = self.magicfolder.uploader.set_hook('processed')
286 # down_proc = self.magicfolder.downloader.set_hook('processed')
287 path = os.path.join(self.local_dir, u'foo')
288 fileutil.write(path, 'foo\n')
289 self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
291 self.assertTrue(os.path.exists(path))
294 up_proc = self.magicfolder.uploader.set_hook('processed')
296 self.notify(to_filepath(path), self.inotify.IN_DELETE)
298 self.assertFalse(os.path.exists(path))
300 # ensure we still have a DB entry, and that the version is 1
301 node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
302 self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
303 self.failUnlessEqual(metadata['version'], 1)
305 # restore the file, with different contents
306 up_proc = self.magicfolder.uploader.set_hook('processed')
307 path = os.path.join(self.local_dir, u'foo')
308 fileutil.write(path, 'bar\n')
309 self.notify(to_filepath(path), self.inotify.IN_CLOSE_WRITE)
312 # ensure we still have a DB entry, and that the version is 2
313 node, metadata = yield self.magicfolder.downloader._get_collective_latest_file(u'foo')
314 self.assertTrue(node is not None, "Failed to find %r in DMD" % (path,))
315 self.failUnlessEqual(metadata['version'], 2)
318 yield self.cleanup(None)
320 @defer.inlineCallbacks
321 def test_alice_delete_bob_restore(self):
322 alice_clock = task.Clock()
323 bob_clock = task.Clock()
324 yield self.setup_alice_and_bob(alice_clock, bob_clock)
325 alice_dir = self.alice_magicfolder.uploader._local_path_u
326 bob_dir = self.bob_magicfolder.uploader._local_path_u
327 alice_fname = os.path.join(alice_dir, 'blam')
328 bob_fname = os.path.join(bob_dir, 'blam')
331 # alice creates a file, bob downloads it
332 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
333 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
335 fileutil.write(alice_fname, 'contents0\n')
336 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
338 alice_clock.advance(0)
339 yield alice_proc # alice uploads
342 yield bob_proc # bob downloads
345 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
346 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
347 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
348 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
349 yield self.failUnlessReallyEqual(
350 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
353 yield self.failUnlessReallyEqual(
354 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
359 # now bob deletes it (bob should upload, alice download)
360 bob_proc = self.bob_magicfolder.uploader.set_hook('processed')
361 alice_proc = self.alice_magicfolder.downloader.set_hook('processed')
363 self.notify(to_filepath(bob_fname), self.inotify.IN_DELETE, magic=self.bob_magicfolder)
367 alice_clock.advance(0)
371 node, metadata = yield self.alice_magicfolder.downloader._get_collective_latest_file(u'blam')
372 self.assertTrue(metadata['deleted'])
373 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
374 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
375 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
376 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
378 print("ALICE RESTORE")
379 # now alice restores it (alice should upload, bob download)
380 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
381 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
382 fileutil.write(alice_fname, 'new contents\n')
383 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
385 alice_clock.advance(0)
391 node, metadata = yield self.alice_magicfolder.downloader._get_collective_latest_file(u'blam')
392 self.assertTrue('deleted' not in metadata or not metadata['deleted'])
393 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 2)
394 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 2)
395 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 2)
396 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 2)
400 d0 = self.alice_magicfolder.finish()
401 alice_clock.advance(0)
404 d1 = self.bob_magicfolder.finish()
408 @defer.inlineCallbacks
409 def test_alice_sees_bobs_delete_with_error(self):
410 # alice creates a file, bob deletes it -- and we also arrange
411 # for Alice's file to have "gone missing" as well.
412 alice_clock = task.Clock()
413 bob_clock = task.Clock()
414 yield self.setup_alice_and_bob(alice_clock, bob_clock)
415 alice_dir = self.alice_magicfolder.uploader._local_path_u
416 bob_dir = self.bob_magicfolder.uploader._local_path_u
417 alice_fname = os.path.join(alice_dir, 'blam')
418 bob_fname = os.path.join(bob_dir, 'blam')
421 # alice creates a file, bob downloads it
422 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
423 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
425 fileutil.write(alice_fname, 'contents0\n')
426 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
428 alice_clock.advance(0)
429 yield alice_proc # alice uploads
432 yield bob_proc # bob downloads
435 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
436 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
437 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
438 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
439 yield self.failUnlessReallyEqual(
440 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
443 yield self.failUnlessReallyEqual(
444 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
448 # now bob deletes it (bob should upload, alice download)
449 bob_proc = self.bob_magicfolder.uploader.set_hook('processed')
450 alice_proc = self.alice_magicfolder.downloader.set_hook('processed')
452 self.notify(to_filepath(bob_fname), self.inotify.IN_DELETE, magic=self.bob_magicfolder)
453 # just after notifying bob, we also delete alice's,
454 # covering the 'except' flow in _rename_deleted_file()
455 os.unlink(alice_fname)
459 alice_clock.advance(0)
463 node, metadata = yield self.alice_magicfolder.downloader._get_collective_latest_file(u'blam')
464 self.assertTrue(metadata['deleted'])
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)
472 d0 = self.alice_magicfolder.finish()
473 alice_clock.advance(0)
476 d1 = self.bob_magicfolder.finish()
480 @defer.inlineCallbacks
481 def test_alice_create_bob_update(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')
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')
495 fileutil.write(alice_fname, 'contents0\n')
496 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
498 alice_clock.advance(0)
499 yield alice_proc # alice uploads
502 yield bob_proc # bob downloads
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),
513 yield self.failUnlessReallyEqual(
514 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
518 # now bob updates it (bob should upload, alice download)
519 bob_proc = self.bob_magicfolder.uploader.set_hook('processed')
520 alice_proc = self.alice_magicfolder.downloader.set_hook('processed')
521 fileutil.write(bob_fname, 'bob wuz here\n')
522 self.notify(to_filepath(bob_fname), self.inotify.IN_CLOSE_WRITE, magic=self.bob_magicfolder)
526 alice_clock.advance(0)
530 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
531 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
532 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
533 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
537 d0 = self.alice_magicfolder.finish()
538 alice_clock.advance(0)
541 d1 = self.bob_magicfolder.finish()
545 @defer.inlineCallbacks
546 def test_alice_delete_and_restore(self):
547 alice_clock = task.Clock()
548 bob_clock = task.Clock()
549 yield self.setup_alice_and_bob(alice_clock, bob_clock)
550 alice_dir = self.alice_magicfolder.uploader._local_path_u
551 bob_dir = self.bob_magicfolder.uploader._local_path_u
552 alice_fname = os.path.join(alice_dir, 'blam')
553 bob_fname = os.path.join(bob_dir, 'blam')
556 # alice creates a file, bob downloads it
557 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
558 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
560 fileutil.write(alice_fname, 'contents0\n')
561 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
563 alice_clock.advance(0)
564 yield alice_proc # alice uploads
567 yield bob_proc # bob downloads
570 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
571 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 0)
572 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
573 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 0)
574 yield self.failUnlessReallyEqual(
575 self._get_count('downloader.objects_failed', client=self.bob_magicfolder._client),
578 yield self.failUnlessReallyEqual(
579 self._get_count('downloader.objects_downloaded', client=self.bob_magicfolder._client),
582 self.failUnless(os.path.exists(bob_fname))
584 # now alice deletes it (alice should upload, bob download)
585 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
586 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
587 os.unlink(alice_fname)
588 self.notify(to_filepath(alice_fname), self.inotify.IN_DELETE, magic=self.alice_magicfolder)
590 alice_clock.advance(0)
596 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 1)
597 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 1)
598 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 1)
599 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 1)
600 self.failIf(os.path.exists(bob_fname))
602 # now alice restores the file (with new contents)
603 alice_proc = self.alice_magicfolder.uploader.set_hook('processed')
604 bob_proc = self.bob_magicfolder.downloader.set_hook('processed')
605 fileutil.write(alice_fname, 'alice wuz here\n')
606 self.notify(to_filepath(alice_fname), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
608 alice_clock.advance(0)
614 yield self._check_version_in_dmd(self.bob_magicfolder, u"blam", 2)
615 yield self._check_version_in_local_db(self.bob_magicfolder, u"blam", 2)
616 yield self._check_version_in_dmd(self.alice_magicfolder, u"blam", 2)
617 yield self._check_version_in_local_db(self.alice_magicfolder, u"blam", 2)
618 self.failUnless(os.path.exists(bob_fname))
622 d0 = self.alice_magicfolder.finish()
623 alice_clock.advance(0)
626 d1 = self.bob_magicfolder.finish()
630 def test_magic_folder(self):
632 self.local_dir = os.path.join(self.basedir, self.unicode_or_fallback(u"loc\u0101l_dir", u"local_dir"))
633 self.mkdir_nonascii(self.local_dir)
635 d = self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
636 d.addCallback(self._restart_client)
638 # Write something short enough for a LIT file.
639 d.addCallback(lambda ign: self._check_file(u"short", "test"))
641 # Write to the same file again with different data.
642 d.addCallback(lambda ign: self._check_file(u"short", "different"))
644 # Test that temporary files are not uploaded.
645 d.addCallback(lambda ign: self._check_file(u"tempfile", "test", temporary=True))
647 # Test creation of a subdirectory.
648 d.addCallback(lambda ign: self._check_mkdir(u"directory"))
650 # Write something longer, and also try to test a Unicode name if the fs can represent it.
651 name_u = self.unicode_or_fallback(u"l\u00F8ng", u"long")
652 d.addCallback(lambda ign: self._check_file(name_u, "test"*100))
654 # TODO: test that causes an upload failure.
655 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
657 d.addBoth(self.cleanup)
660 def _check_mkdir(self, name_u):
661 return self._check_file(name_u + u"/", "", directory=True)
663 def _check_file(self, name_u, data, temporary=False, directory=False):
664 precondition(not (temporary and directory), temporary=temporary, directory=directory)
666 print "%r._check_file(%r, %r, temporary=%r, directory=%r)" % (self, name_u, data, temporary, directory)
667 previously_uploaded = self._get_count('uploader.objects_succeeded')
668 previously_disappeared = self._get_count('uploader.objects_disappeared')
670 d = self.magicfolder.uploader.set_hook('processed')
672 path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
673 path = to_filepath(path_u)
677 event_mask = self.inotify.IN_CREATE | self.inotify.IN_ISDIR
679 # We don't use FilePath.setContent() here because it creates a temporary file that
680 # is renamed into place, which causes events that the test is not expecting.
681 f = open(path_u, "wb")
683 if temporary and sys.platform != "win32":
688 if temporary and sys.platform == "win32":
690 self.notify(path, self.inotify.IN_DELETE, flush=False)
691 event_mask = self.inotify.IN_CLOSE_WRITE
693 self.notify(path, event_mask)
694 encoded_name_u = magicpath.path2magic(name_u)
696 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
698 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
699 previously_disappeared + 1))
702 print "here %r %r" % (n, res)
705 d.addCallback(lambda ign: self.upload_dirnode.list())
706 d.addBoth(_here, 1.5)
707 d.addCallback(lambda ign: self.upload_dirnode.get(encoded_name_u))
709 d.addCallback(download_to_data)
711 d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
713 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
714 previously_uploaded + 1))
716 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
719 def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
720 encoded_name_u = magicpath.path2magic(relpath_u)
721 d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
722 def check_latest(result):
723 if result[0] is not None:
724 node, metadata = result
725 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
726 d.addCallback(check_latest)
729 def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
730 db_entry = magicfolder._db.get_db_entry(relpath_u)
731 if db_entry is not None:
732 #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
733 self.failUnlessEqual(db_entry.version, expected_version)
735 def _check_file_gone(self, magicfolder, relpath_u):
736 path = os.path.join(magicfolder.uploader._local_path_u, relpath_u)
737 self.assertTrue(not os.path.exists(path))
739 def _check_uploader_count(self, name, expected, magic=None):
740 self.failUnlessReallyEqual(self._get_count('uploader.'+name, client=(magic or self.alice_magicfolder)._client),
743 def _check_downloader_count(self, name, expected, magic=None):
744 self.failUnlessReallyEqual(self._get_count('downloader.'+name, client=(magic or self.bob_magicfolder)._client),
747 def test_alice_bob(self):
748 alice_clock = task.Clock()
749 bob_clock = task.Clock()
750 d = self.setup_alice_and_bob(alice_clock, bob_clock)
752 def _wait_for_Alice(ign, downloaded_d):
753 print "Now waiting for Alice to download\n"
754 alice_clock.advance(0)
757 def _wait_for_Bob(ign, downloaded_d):
758 print "Now waiting for Bob to download\n"
762 def _wait_for(ign, something_to_do, alice=True):
764 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
765 uploaded_d = self.alice_magicfolder.uploader.set_hook('processed')
767 downloaded_d = self.alice_magicfolder.downloader.set_hook('processed')
768 uploaded_d = self.bob_magicfolder.uploader.set_hook('processed')
771 print "Waiting for Alice to upload\n"
772 alice_clock.advance(0)
773 uploaded_d.addCallback(_wait_for_Bob, downloaded_d)
775 print "Waiting for Bob to upload\n"
777 uploaded_d.addCallback(_wait_for_Alice, downloaded_d)
780 def Alice_to_write_a_file():
781 print "Alice writes a file\n"
782 self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
783 fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
784 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
785 d.addCallback(_wait_for, Alice_to_write_a_file)
787 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
788 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
789 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
790 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1))
791 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1))
792 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
793 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
794 d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0))
795 d.addCallback(lambda ign: self._check_uploader_count('objects_conflicted', 0, magic=self.bob_magicfolder))
797 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
798 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
799 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1))
800 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 0, magic=self.bob_magicfolder))
802 def Alice_to_delete_file():
803 print "Alice deletes the file!\n"
804 os.unlink(self.file_path)
805 self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE, magic=self.alice_magicfolder)
806 d.addCallback(_wait_for, Alice_to_delete_file)
808 def notify_bob_moved(ign):
809 d0 = self.bob_magicfolder.uploader.set_hook('processed')
810 p = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
811 self.notify(to_filepath(p), self.inotify.IN_MOVED_FROM, magic=self.bob_magicfolder, flush=False)
812 self.notify(to_filepath(p + u'.backup'), self.inotify.IN_MOVED_TO, magic=self.bob_magicfolder)
815 d.addCallback(notify_bob_moved)
817 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
818 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
819 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
820 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2))
821 d.addCallback(lambda ign: self._check_uploader_count('objects_not_uploaded', 1, magic=self.bob_magicfolder))
822 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 1, magic=self.bob_magicfolder))
824 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
825 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
826 d.addCallback(lambda ign: self._check_file_gone(self.bob_magicfolder, u"file1"))
827 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
828 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2))
830 def Alice_to_rewrite_file():
831 print "Alice rewrites file\n"
832 self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
833 fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
834 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
835 d.addCallback(_wait_for, Alice_to_rewrite_file)
837 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
838 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
839 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0))
840 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3))
841 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 3))
842 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0))
843 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0))
844 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
845 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
847 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 2))
848 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 2))
849 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0))
850 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
852 path_u = u"/tmp/magic_folder_test"
853 encoded_path_u = magicpath.path2magic(u"/tmp/magic_folder_test")
855 def Alice_tries_to_p0wn_Bob(ign):
856 print "Alice tries to p0wn Bob\n"
857 self.objects_excluded = self._get_count('downloader.objects_excluded', client=self.bob_magicfolder._client)
858 processed_d = self.bob_magicfolder.downloader.set_hook('processed')
860 # upload a file that would provoke the security bug from #2506
861 uploadable = Data("", self.alice_magicfolder._client.convergence)
862 alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
864 d2 = alice_dmd.add_file(encoded_path_u, uploadable, metadata={"version": 0}, overwrite=True)
865 d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
866 d2.addCallback(_wait_for_Bob, processed_d)
868 d.addCallback(Alice_tries_to_p0wn_Bob)
870 d.addCallback(lambda ign: self.failIf(os.path.exists(path_u)))
871 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, encoded_path_u, None))
872 d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', self.objects_excluded+1))
873 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3))
874 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
875 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
877 def Bob_to_rewrite_file():
878 print "Bob rewrites file\n"
879 self.file_path = abspath_expanduser_unicode(u"file1", base=self.bob_magicfolder.uploader._local_path_u)
880 print "---- bob's file is %r" % (self.file_path,)
881 fileutil.write(self.file_path, "No white rabbit to be found.")
882 self.magicfolder = self.bob_magicfolder
883 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
884 d.addCallback(lambda ign: _wait_for(None, Bob_to_rewrite_file, alice=False))
886 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 3))
887 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 3))
888 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
889 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 2, magic=self.bob_magicfolder))
890 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 1, magic=self.bob_magicfolder))
891 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
892 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
893 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0))
895 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 3))
896 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 3))
897 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
898 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1, magic=self.alice_magicfolder))
899 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
901 def Alice_conflicts_with_Bobs_last_downloaded_uri():
902 print "Alice conflicts with Bob\n"
903 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
904 uploadable = Data("do not follow the white rabbit", self.alice_magicfolder._client.convergence)
905 alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
906 d2 = alice_dmd.add_file(u"file1", uploadable,
907 metadata={"version": 5,
908 "last_downloaded_uri" : "URI:LIT:" },
910 print "Waiting for Alice to upload\n"
911 d2.addCallback(lambda ign: bob_clock.advance(6))
912 d2.addCallback(lambda ign: downloaded_d)
913 d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
916 d.addCallback(lambda ign: Alice_conflicts_with_Bobs_last_downloaded_uri())
917 # XXX fix the code so that it doesn't increment objects_excluded each turn
918 #d.addCallback(lambda ign: self._check_downloader_count('objects_excluded', 1))
919 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 4))
920 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 1))
921 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 1, magic=self.alice_magicfolder))
922 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
923 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
925 # prepare to perform another conflict test
926 def Alice_to_write_file2():
927 print "Alice writes a file\n"
928 self.file_path = abspath_expanduser_unicode(u"file2", base=self.alice_magicfolder.uploader._local_path_u)
929 fileutil.write(self.file_path, "something")
930 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
931 d.addCallback(_wait_for, Alice_to_write_file2)
932 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file2", 0))
933 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
934 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
936 def Bob_to_rewrite_file2():
937 print "Bob rewrites file\n"
938 self.file_path = abspath_expanduser_unicode(u"file2", base=self.bob_magicfolder.uploader._local_path_u)
939 print "---- bob's file is %r" % (self.file_path,)
940 fileutil.write(self.file_path, "roger roger. what vector?")
941 self.magicfolder = self.bob_magicfolder
942 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
943 d.addCallback(lambda ign: _wait_for(None, Bob_to_rewrite_file2, alice=False))
944 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file2", 1))
945 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 5))
946 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 1))
947 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
948 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3, magic=self.bob_magicfolder))
949 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 2, magic=self.bob_magicfolder))
950 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
951 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
952 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
953 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
954 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2, magic=self.alice_magicfolder))
956 # XXX here we advance the clock and then test again to make sure no values are monotonically increasing
957 # with each queue turn ;-p
958 alice_clock.advance(6)
960 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file2", 1))
961 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 5))
962 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 1))
963 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
964 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3, magic=self.bob_magicfolder))
965 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 2, magic=self.bob_magicfolder))
966 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
967 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
968 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
969 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
970 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2, magic=self.alice_magicfolder))
972 def Alice_conflicts_with_Bobs_last_uploaded_uri():
973 print "Alice conflicts with Bob\n"
974 encoded_path_u = magicpath.path2magic(u"file2")
975 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
976 uploadable = Data("rabbits with sharp fangs", self.alice_magicfolder._client.convergence)
977 alice_dmd = self.alice_magicfolder.uploader._upload_dirnode
978 d2 = alice_dmd.add_file(u"file2", uploadable,
979 metadata={"version": 5,
980 "last_uploaded_uri" : "URI:LIT:" },
982 print "Waiting for Alice to upload\n"
983 d2.addCallback(lambda ign: bob_clock.advance(6))
984 d2.addCallback(lambda ign: downloaded_d)
985 d2.addCallback(lambda ign: self.failUnless(alice_dmd.has_child(encoded_path_u)))
987 d.addCallback(lambda ign: Alice_conflicts_with_Bobs_last_uploaded_uri())
988 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file2", 5))
989 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 6))
990 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 2))
991 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
992 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 3, magic=self.bob_magicfolder))
993 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 2, magic=self.bob_magicfolder))
994 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
995 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
996 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
997 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
998 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2, magic=self.alice_magicfolder))
1000 alice_clock.advance(6)
1001 bob_clock.advance(6)
1002 alice_clock.advance(6)
1003 bob_clock.advance(6)
1005 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2, magic=self.alice_magicfolder))
1006 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
1007 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 2))
1008 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 6))
1010 # prepare to perform another conflict test
1011 def Alice_to_write_file3():
1012 print "Alice writes a file\n"
1013 self.file_path = abspath_expanduser_unicode(u"file3", base=self.alice_magicfolder.uploader._local_path_u)
1014 fileutil.write(self.file_path, "something")
1015 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE, magic=self.alice_magicfolder)
1016 d.addCallback(_wait_for, Alice_to_write_file3)
1017 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file3", 0))
1018 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
1019 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 7))
1020 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 2, magic=self.alice_magicfolder))
1021 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 2))
1022 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
1024 def Bob_to_rewrite_file3():
1025 print "Bob rewrites file\n"
1026 self.file_path = abspath_expanduser_unicode(u"file3", base=self.bob_magicfolder.uploader._local_path_u)
1027 print "---- bob's file is %r" % (self.file_path,)
1028 fileutil.write(self.file_path, "roger roger")
1029 self.magicfolder = self.bob_magicfolder
1030 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
1031 d.addCallback(lambda ign: _wait_for(None, Bob_to_rewrite_file3, alice=False))
1032 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file3", 1))
1033 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 7))
1034 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 2))
1035 d.addCallback(lambda ign: self._check_uploader_count('objects_failed', 0, magic=self.bob_magicfolder))
1036 d.addCallback(lambda ign: self._check_uploader_count('objects_succeeded', 4, magic=self.bob_magicfolder))
1037 d.addCallback(lambda ign: self._check_uploader_count('files_uploaded', 3, magic=self.bob_magicfolder))
1038 d.addCallback(lambda ign: self._check_uploader_count('objects_queued', 0, magic=self.bob_magicfolder))
1039 d.addCallback(lambda ign: self._check_uploader_count('directories_created', 0, magic=self.bob_magicfolder))
1040 d.addCallback(lambda ign: self._check_downloader_count('objects_conflicted', 0, magic=self.alice_magicfolder))
1041 d.addCallback(lambda ign: self._check_downloader_count('objects_failed', 0, magic=self.alice_magicfolder))
1042 d.addCallback(lambda ign: self._check_downloader_count('objects_downloaded', 3, magic=self.alice_magicfolder))
1046 def _cleanup(ign, magicfolder, clock):
1047 if magicfolder is not None:
1048 d2 = magicfolder.finish()
1052 def cleanup_Alice_and_Bob(result):
1053 print "cleanup alice bob test\n"
1054 d = defer.succeed(None)
1055 d.addCallback(_cleanup, self.alice_magicfolder, alice_clock)
1056 d.addCallback(_cleanup, self.bob_magicfolder, bob_clock)
1057 d.addCallback(lambda ign: result)
1059 d.addBoth(cleanup_Alice_and_Bob)
1063 class MockTest(MagicFolderTestMixin, unittest.TestCase):
1064 """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
1067 MagicFolderTestMixin.setUp(self)
1068 self.inotify = fake_inotify
1069 self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
1071 def notify(self, path, mask, magic=None, flush=True):
1073 magic = self.magicfolder
1074 magic.uploader._notifier.event(path, mask)
1075 # no flush for the mock test.
1077 def test_errors(self):
1080 errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
1081 os.mkdir(errors_dir)
1082 not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
1083 fileutil.write(not_a_dir, "")
1084 magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
1085 doesnotexist = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
1087 client = self.g.clients[0]
1088 d = client.create_dirnode()
1089 def _check_errors(n):
1090 self.failUnless(IDirectoryNode.providedBy(n))
1091 upload_dircap = n.get_uri()
1092 readonly_dircap = n.get_readonly_uri()
1094 self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
1095 MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
1096 self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
1097 MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
1098 self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
1099 MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
1100 self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
1101 MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
1102 self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
1103 MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb)
1104 self.shouldFail(AssertionError, 'collective dircap', 'is not a readonly cap to a directory',
1105 MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
1107 def _not_implemented():
1108 raise NotImplementedError("blah")
1109 self.patch(magic_folder, 'get_inotify_module', _not_implemented)
1110 self.shouldFail(NotImplementedError, 'unsupported', 'blah',
1111 MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
1112 d.addCallback(_check_errors)
1115 def test_write_downloaded_file(self):
1116 workdir = u"cli/MagicFolder/write-downloaded-file"
1117 local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
1119 class TestWriteFileMixin(WriteFileMixin):
1120 def _log(self, msg):
1123 writefile = TestWriteFileMixin()
1125 # create a file with name "foobar" with content "foo"
1126 # write downloaded file content "bar" into "foobar" with is_conflict = False
1127 fileutil.make_dirs(workdir)
1128 fileutil.write(local_file, "foo")
1130 # if is_conflict is False, then the .conflict file shouldn't exist.
1131 writefile._write_downloaded_file(local_file, "bar", False, None)
1132 conflicted_path = local_file + u".conflict"
1133 self.failIf(os.path.exists(conflicted_path))
1135 # At this point, the backup file should exist with content "foo"
1136 backup_path = local_file + u".backup"
1137 self.failUnless(os.path.exists(backup_path))
1138 self.failUnlessEqual(fileutil.read(backup_path), "foo")
1140 # .tmp file shouldn't exist
1141 self.failIf(os.path.exists(local_file + u".tmp"))
1143 # .. and the original file should have the new content
1144 self.failUnlessEqual(fileutil.read(local_file), "bar")
1146 # now a test for conflicted case
1147 writefile._write_downloaded_file(local_file, "bar", True, None)
1148 self.failUnless(os.path.exists(conflicted_path))
1150 # .tmp file shouldn't exist
1151 self.failIf(os.path.exists(local_file + u".tmp"))
1154 class RealTest(MagicFolderTestMixin, unittest.TestCase):
1155 """This is skipped unless both Twisted and the platform support inotify."""
1158 MagicFolderTestMixin.setUp(self)
1159 self.inotify = magic_folder.get_inotify_module()
1161 def notify(self, path, mask, magic=None, flush=True):
1162 # Writing to the filesystem causes the notification.
1163 # However, flushing filesystem buffers may be necessary on Windows.
1165 fileutil.flush_volume(path.path)
1168 magic_folder.get_inotify_module()
1169 except NotImplementedError:
1170 RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."