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.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
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
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 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)
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))
148 # FIXME check that Bob downloaded/created the empty tree.
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)
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))
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)
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))
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")
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))
201 d.addBoth(self.cleanup)
204 def test_persistence(self):
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.
212 self.local_dir = abspath_expanduser_unicode(u"test_persistence", base=self.basedir)
213 self.mkdir_nonascii(self.local_dir)
214 self.collective_dircap = ""
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)
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)
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)
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)
243 def test_magic_folder(self):
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)
248 d = self.create_invite_join_magic_folder(u"Alice\u0101", self.local_dir)
249 d.addCallback(self._restart_client)
251 # Write something short enough for a LIT file.
252 d.addCallback(lambda ign: self._check_file(u"short", "test"))
254 # Write to the same file again with different data.
255 d.addCallback(lambda ign: self._check_file(u"short", "different"))
257 # Test that temporary files are not uploaded.
258 d.addCallback(lambda ign: self._check_file(u"tempfile", "test", temporary=True))
260 # Test creation of a subdirectory.
261 d.addCallback(lambda ign: self._check_mkdir(u"directory"))
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))
267 # TODO: test that causes an upload failure.
268 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
270 d.addBoth(self.cleanup)
273 def _check_mkdir(self, name_u):
274 return self._check_file(name_u + u"/", "", directory=True)
276 def _check_file(self, name_u, data, temporary=False, directory=False):
277 precondition(not (temporary and directory), temporary=temporary, directory=directory)
279 previously_uploaded = self._get_count('uploader.objects_succeeded')
280 previously_disappeared = self._get_count('uploader.objects_disappeared')
282 d = self.magicfolder.uploader.set_hook('processed')
284 path_u = abspath_expanduser_unicode(name_u, base=self.local_dir)
285 path = to_filepath(path_u)
289 event_mask = self.inotify.IN_CREATE | self.inotify.IN_ISDIR
291 # We don't use FilePath.setContent() here because it creates a temporary file that
292 # is renamed into place, which causes events that the test is not expecting.
293 f = open(path_u, "wb")
295 if temporary and sys.platform != "win32":
300 if temporary and sys.platform == "win32":
302 self.notify(path, self.inotify.IN_DELETE)
303 event_mask = self.inotify.IN_CLOSE_WRITE
305 fileutil.flush_volume(path_u)
306 self.notify(path, event_mask)
307 encoded_name_u = magicpath.path2magic(name_u)
309 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_failed'), 0))
311 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_disappeared'),
312 previously_disappeared + 1))
314 d.addCallback(lambda ign: self.upload_dirnode.get(encoded_name_u))
315 d.addCallback(download_to_data)
316 d.addCallback(lambda actual_data: self.failUnlessReallyEqual(actual_data, data))
317 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_succeeded'),
318 previously_uploaded + 1))
320 d.addCallback(lambda ign: self.failUnlessReallyEqual(self._get_count('uploader.objects_queued'), 0))
323 def _check_version_in_dmd(self, magicfolder, relpath_u, expected_version):
324 encoded_name_u = magicpath.path2magic(relpath_u)
325 d = magicfolder.downloader._get_collective_latest_file(encoded_name_u)
326 def check_latest(result):
327 if result[0] is not None:
328 node, metadata = result
329 d.addCallback(lambda ign: self.failUnlessEqual(metadata['version'], expected_version))
330 d.addCallback(check_latest)
333 def _check_version_in_local_db(self, magicfolder, relpath_u, expected_version):
334 version = magicfolder._db.get_local_file_version(relpath_u)
335 #print "_check_version_in_local_db: %r has version %s" % (relpath_u, version)
336 self.failUnlessEqual(version, expected_version)
338 def test_alice_bob(self):
339 alice_clock = task.Clock()
340 bob_clock = task.Clock()
341 d = self.setup_alice_and_bob(alice_clock, bob_clock)
343 def _check_uploader_count(ign, name, expected):
344 self.failUnlessReallyEqual(self._get_count('uploader.'+name, client=self.alice_magicfolder._client),
346 def _check_downloader_count(ign, name, expected):
347 self.failUnlessReallyEqual(self._get_count('downloader.'+name, client=self.bob_magicfolder._client),
350 def _wait_for(ign, something_to_do):
351 downloaded_d = self.bob_magicfolder.downloader.set_hook('processed')
352 uploaded_d = self.alice_magicfolder.uploader.set_hook('processed')
354 print "Waiting for Alice to upload\n"
355 alice_clock.advance(0)
356 def _wait_for_Bob(ign):
357 print "Now waiting for Bob to download\n"
360 uploaded_d.addCallback(_wait_for_Bob)
363 def Alice_to_write_a_file():
364 print "Alice writes a file\n"
365 self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
366 fileutil.write(self.file_path, "meow, meow meow. meow? meow meow! meow.")
367 self.magicfolder = self.alice_magicfolder
368 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
369 d.addCallback(_wait_for, Alice_to_write_a_file)
371 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 0))
372 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 0))
373 d.addCallback(_check_uploader_count, 'objects_failed', 0)
374 d.addCallback(_check_uploader_count, 'objects_succeeded', 1)
375 d.addCallback(_check_uploader_count, 'files_uploaded', 1)
376 d.addCallback(_check_uploader_count, 'objects_queued', 0)
377 d.addCallback(_check_uploader_count, 'directories_created', 0)
379 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 0))
380 d.addCallback(_check_downloader_count, 'objects_failed', 0)
381 d.addCallback(_check_downloader_count, 'objects_downloaded', 1)
383 def Alice_to_delete_file():
384 print "Alice deletes the file!\n"
385 os.unlink(self.file_path)
386 self.magicfolder = self.alice_magicfolder
387 self.notify(to_filepath(self.file_path), self.inotify.IN_DELETE)
388 d.addCallback(_wait_for, Alice_to_delete_file)
390 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 1))
391 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 1))
392 d.addCallback(_check_uploader_count, 'objects_failed', 0)
393 d.addCallback(_check_uploader_count, 'objects_succeeded', 2)
395 d.addCallback(lambda ign: self._check_version_in_local_db(self.bob_magicfolder, u"file1", 1))
396 d.addCallback(lambda ign: self._check_version_in_dmd(self.bob_magicfolder, u"file1", 1))
397 d.addCallback(_check_downloader_count, 'objects_failed', 0)
398 d.addCallback(_check_downloader_count, 'objects_downloaded', 2)
400 def Alice_to_rewrite_file():
401 print "Alice rewrites file\n"
402 self.file_path = abspath_expanduser_unicode(u"file1", base=self.alice_magicfolder.uploader._local_path_u)
403 fileutil.write(self.file_path, "Alice suddenly sees the white rabbit running into the forest.")
404 self.notify(to_filepath(self.file_path), self.inotify.IN_CLOSE_WRITE)
405 d.addCallback(_wait_for, Alice_to_rewrite_file)
407 d.addCallback(lambda ign: self._check_version_in_dmd(self.alice_magicfolder, u"file1", 2))
408 d.addCallback(lambda ign: self._check_version_in_local_db(self.alice_magicfolder, u"file1", 2))
409 d.addCallback(_check_uploader_count, 'objects_failed', 0)
410 d.addCallback(_check_uploader_count, 'objects_succeeded', 3)
411 d.addCallback(_check_uploader_count, 'files_uploaded', 3)
412 d.addCallback(_check_uploader_count, 'objects_queued', 0)
413 d.addCallback(_check_uploader_count, 'directories_created', 0)
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(_check_downloader_count, 'objects_failed', 0)
418 d.addCallback(_check_downloader_count, 'objects_downloaded', 3)
420 def _cleanup(ign, magicfolder, clock):
421 if magicfolder is not None:
422 d2 = magicfolder.finish()
426 def cleanup_Alice_and_Bob(result):
427 print "cleanup alice bob test\n"
428 d = defer.succeed(None)
429 d.addCallback(_cleanup, self.alice_magicfolder, alice_clock)
430 d.addCallback(_cleanup, self.bob_magicfolder, bob_clock)
431 d.addCallback(lambda ign: result)
433 d.addBoth(cleanup_Alice_and_Bob)
437 class MockTest(MagicFolderTestMixin, unittest.TestCase):
438 """This can run on any platform, and even if twisted.internet.inotify can't be imported."""
441 MagicFolderTestMixin.setUp(self)
442 self.inotify = fake_inotify
443 self.patch(magic_folder, 'get_inotify_module', lambda: self.inotify)
445 def notify(self, path, mask):
446 self.magicfolder.uploader._notifier.event(path, mask)
448 def test_errors(self):
451 errors_dir = abspath_expanduser_unicode(u"errors_dir", base=self.basedir)
453 not_a_dir = abspath_expanduser_unicode(u"NOT_A_DIR", base=self.basedir)
454 fileutil.write(not_a_dir, "")
455 magicfolderdb = abspath_expanduser_unicode(u"magicfolderdb", base=self.basedir)
456 doesnotexist = abspath_expanduser_unicode(u"doesnotexist", base=self.basedir)
458 client = self.g.clients[0]
459 d = client.create_dirnode()
460 def _check_errors(n):
461 self.failUnless(IDirectoryNode.providedBy(n))
462 upload_dircap = n.get_uri()
463 readonly_dircap = n.get_readonly_uri()
465 self.shouldFail(AssertionError, 'nonexistent local.directory', 'there is no directory',
466 MagicFolder, client, upload_dircap, '', doesnotexist, magicfolderdb)
467 self.shouldFail(AssertionError, 'non-directory local.directory', 'is not a directory',
468 MagicFolder, client, upload_dircap, '', not_a_dir, magicfolderdb)
469 self.shouldFail(AssertionError, 'bad upload.dircap', 'does not refer to a directory',
470 MagicFolder, client, 'bad', '', errors_dir, magicfolderdb)
471 self.shouldFail(AssertionError, 'non-directory upload.dircap', 'does not refer to a directory',
472 MagicFolder, client, 'URI:LIT:foo', '', errors_dir, magicfolderdb)
473 self.shouldFail(AssertionError, 'readonly upload.dircap', 'is not a writecap to a directory',
474 MagicFolder, client, readonly_dircap, '', errors_dir, magicfolderdb,)
475 self.shouldFail(AssertionError, 'collective dircap',
476 "The URI in 'private/collective_dircap' is not a readonly cap to a directory.",
477 MagicFolder, client, upload_dircap, upload_dircap, errors_dir, magicfolderdb)
479 def _not_implemented():
480 raise NotImplementedError("blah")
481 self.patch(magic_folder, 'get_inotify_module', _not_implemented)
482 self.shouldFail(NotImplementedError, 'unsupported', 'blah',
483 MagicFolder, client, upload_dircap, '', errors_dir, magicfolderdb)
484 d.addCallback(_check_errors)
487 def test_write_downloaded_file(self):
488 workdir = u"cli/MagicFolder/write-downloaded-file"
489 local_file = fileutil.abspath_expanduser_unicode(os.path.join(workdir, "foobar"))
491 class TestWriteFileMixin(WriteFileMixin):
495 writefile = TestWriteFileMixin()
497 # create a file with name "foobar" with content "foo"
498 # write downloaded file content "bar" into "foobar" with is_conflict = False
499 fileutil.make_dirs(workdir)
500 fileutil.write(local_file, "foo")
502 # if is_conflict is False, then the .conflict file shouldn't exist.
503 writefile._write_downloaded_file(local_file, "bar", False, None)
504 conflicted_path = local_file + u".conflict"
505 self.failIf(os.path.exists(conflicted_path))
507 # At this point, the backup file should exist with content "foo"
508 backup_path = local_file + u".backup"
509 self.failUnless(os.path.exists(backup_path))
510 self.failUnlessEqual(fileutil.read(backup_path), "foo")
512 # .tmp file shouldn't exist
513 self.failIf(os.path.exists(local_file + u".tmp"))
515 # .. and the original file should have the new content
516 self.failUnlessEqual(fileutil.read(local_file), "bar")
518 # now a test for conflicted case
519 writefile._write_downloaded_file(local_file, "bar", True, None)
520 self.failUnless(os.path.exists(conflicted_path))
522 # .tmp file shouldn't exist
523 self.failIf(os.path.exists(local_file + u".tmp"))
526 class RealTest(MagicFolderTestMixin, unittest.TestCase):
527 """This is skipped unless both Twisted and the platform support inotify."""
530 MagicFolderTestMixin.setUp(self)
531 self.inotify = magic_folder.get_inotify_module()
533 def notify(self, path, mask):
534 # Writing to the filesystem causes the notification.
538 magic_folder.get_inotify_module()
539 except NotImplementedError:
540 RealTest.skip = "Magic Folder support can only be tested for-real on an OS that supports inotify or equivalent."