4 from twisted.trial import unittest
5 from twisted.internet import defer
6 from twisted.internet import reactor
7 from twisted.python import usage
9 from allmydata.util.assertutil import precondition
10 from allmydata.util import fileutil
11 from allmydata.scripts.common import get_aliases
12 from allmydata.test.no_network import GridTestMixin
13 from .test_cli import CLITestMixin
14 from allmydata.scripts import magic_folder_cli
15 from allmydata.util.fileutil import abspath_expanduser_unicode
16 from allmydata.util.encodingutil import unicode_to_argv
17 from allmydata.frontends.magic_folder import MagicFolder
18 from allmydata import uri
21 class MagicFolderCLITestMixin(CLITestMixin, GridTestMixin):
22 def do_create_magic_folder(self, client_num):
23 d = self.do_cli("magic-folder", "create", "magic:", client_num=client_num)
24 def _done((rc,stdout,stderr)):
25 self.failUnlessEqual(rc, 0)
26 self.failUnlessIn("Alias 'magic' created", stdout)
27 self.failUnlessEqual(stderr, "")
28 aliases = get_aliases(self.get_clientdir(i=client_num))
29 self.failUnlessIn("magic", aliases)
30 self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
34 def do_invite(self, client_num, nickname):
35 nickname_arg = unicode_to_argv(nickname)
36 d = self.do_cli("magic-folder", "invite", "magic:", nickname_arg, client_num=client_num)
37 def _done((rc, stdout, stderr)):
38 self.failUnlessEqual(rc, 0)
39 return (rc, stdout, stderr)
43 def do_join(self, client_num, local_dir, invite_code):
44 precondition(isinstance(local_dir, unicode), local_dir=local_dir)
45 precondition(isinstance(invite_code, str), invite_code=invite_code)
47 local_dir_arg = unicode_to_argv(local_dir)
48 d = self.do_cli("magic-folder", "join", invite_code, local_dir_arg, client_num=client_num)
49 def _done((rc, stdout, stderr)):
50 self.failUnlessEqual(rc, 0)
51 self.failUnlessEqual(stdout, "")
52 self.failUnlessEqual(stderr, "")
53 return (rc, stdout, stderr)
57 def do_leave(self, client_num):
58 d = self.do_cli("magic-folder", "leave", client_num=client_num)
59 def _done((rc, stdout, stderr)):
60 self.failUnlessEqual(rc, 0)
61 return (rc, stdout, stderr)
65 def check_joined_config(self, client_num, upload_dircap):
66 """Tests that our collective directory has the readonly cap of
69 collective_readonly_cap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
70 u"private", u"collective_dircap"))
71 d = self.do_cli("ls", "--json", collective_readonly_cap, client_num=client_num)
72 def _done((rc, stdout, stderr)):
73 self.failUnlessEqual(rc, 0)
74 return (rc, stdout, stderr)
76 def test_joined_magic_folder((rc,stdout,stderr)):
77 readonly_cap = unicode(uri.from_string(upload_dircap).get_readonly().to_string(), 'utf-8')
78 s = re.search(readonly_cap, stdout)
79 self.failUnless(s is not None)
81 d.addCallback(test_joined_magic_folder)
84 def get_caps_from_files(self, client_num):
85 collective_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
86 u"private", u"collective_dircap"))
87 upload_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
88 u"private", u"magic_folder_dircap"))
89 self.failIf(collective_dircap is None or upload_dircap is None)
90 return collective_dircap, upload_dircap
92 def check_config(self, client_num, local_dir):
93 client_config = fileutil.read(os.path.join(self.get_clientdir(i=client_num), "tahoe.cfg"))
94 local_dir_utf8 = local_dir.encode('utf-8')
95 magic_folder_config = "[magic_folder]\nenabled = True\nlocal.directory = %s" % (local_dir_utf8,)
96 self.failUnlessIn(magic_folder_config, client_config)
98 def create_invite_join_magic_folder(self, nickname, local_dir):
99 nickname_arg = unicode_to_argv(nickname)
100 local_dir_arg = unicode_to_argv(local_dir)
101 d = self.do_cli("magic-folder", "create", "magic:", nickname_arg, local_dir_arg)
102 def _done((rc, stdout, stderr)):
103 self.failUnlessEqual(rc, 0)
105 client = self.get_client()
106 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
107 self.collective_dirnode = client.create_node_from_uri(self.collective_dircap)
108 self.upload_dirnode = client.create_node_from_uri(self.upload_dircap)
110 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
111 d.addCallback(lambda ign: self.check_config(0, local_dir))
114 def cleanup(self, res):
115 d = defer.succeed(None)
116 if self.magicfolder is not None:
117 d.addCallback(lambda ign: self.magicfolder.finish())
118 d.addCallback(lambda ign: res)
121 def init_magicfolder(self, client_num, upload_dircap, collective_dircap, local_magic_dir, clock):
122 dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.get_clientdir(i=client_num))
123 magicfolder = MagicFolder(self.get_client(client_num), upload_dircap, collective_dircap, local_magic_dir,
124 dbfile, 0077, pending_delay=0.2, clock=clock)
125 magicfolder.downloader._turn_delay = 0
127 magicfolder.setServiceParent(self.get_client(client_num))
131 def setup_alice_and_bob(self, alice_clock=reactor, bob_clock=reactor):
132 self.set_up_grid(num_clients=2)
134 self.alice_magicfolder = None
135 self.bob_magicfolder = None
137 alice_magic_dir = abspath_expanduser_unicode(u"Alice-magic", base=self.basedir)
138 self.mkdir_nonascii(alice_magic_dir)
139 bob_magic_dir = abspath_expanduser_unicode(u"Bob-magic", base=self.basedir)
140 self.mkdir_nonascii(bob_magic_dir)
142 # Alice creates a Magic Folder,
143 # invites herself then and joins.
144 d = self.do_create_magic_folder(0)
145 d.addCallback(lambda ign: self.do_invite(0, u"Alice\u00F8"))
146 def get_invite_code(result):
147 self.invite_code = result[1].strip()
148 d.addCallback(get_invite_code)
149 d.addCallback(lambda ign: self.do_join(0, alice_magic_dir, self.invite_code))
150 def get_alice_caps(ign):
151 self.alice_collective_dircap, self.alice_upload_dircap = self.get_caps_from_files(0)
152 d.addCallback(get_alice_caps)
153 d.addCallback(lambda ign: self.check_joined_config(0, self.alice_upload_dircap))
154 d.addCallback(lambda ign: self.check_config(0, alice_magic_dir))
155 def get_Alice_magicfolder(result):
156 self.alice_magicfolder = self.init_magicfolder(0, self.alice_upload_dircap,
157 self.alice_collective_dircap,
158 alice_magic_dir, alice_clock)
160 d.addCallback(get_Alice_magicfolder)
162 # Alice invites Bob. Bob joins.
163 d.addCallback(lambda ign: self.do_invite(0, u"Bob\u00F8"))
164 def get_invite_code(result):
165 self.invite_code = result[1].strip()
166 d.addCallback(get_invite_code)
167 d.addCallback(lambda ign: self.do_join(1, bob_magic_dir, self.invite_code))
168 def get_bob_caps(ign):
169 self.bob_collective_dircap, self.bob_upload_dircap = self.get_caps_from_files(1)
170 d.addCallback(get_bob_caps)
171 d.addCallback(lambda ign: self.check_joined_config(1, self.bob_upload_dircap))
172 d.addCallback(lambda ign: self.check_config(1, bob_magic_dir))
173 def get_Bob_magicfolder(result):
174 self.bob_magicfolder = self.init_magicfolder(1, self.bob_upload_dircap,
175 self.bob_collective_dircap,
176 bob_magic_dir, bob_clock)
178 d.addCallback(get_Bob_magicfolder)
182 class CreateMagicFolder(MagicFolderCLITestMixin, unittest.TestCase):
183 def test_create_and_then_invite_join(self):
184 self.basedir = "cli/MagicFolder/create-and-then-invite-join"
186 local_dir = os.path.join(self.basedir, "magic")
187 abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
189 d = self.do_create_magic_folder(0)
190 d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
191 def get_invite_code_and_join((rc, stdout, stderr)):
192 invite_code = stdout.strip()
193 return self.do_join(0, unicode(local_dir), invite_code)
194 d.addCallback(get_invite_code_and_join)
196 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
197 d.addCallback(get_caps)
198 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
199 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
202 def test_create_error(self):
203 self.basedir = "cli/MagicFolder/create-error"
206 d = self.do_cli("magic-folder", "create", "m a g i c:", client_num=0)
207 def _done((rc, stdout, stderr)):
208 self.failIfEqual(rc, 0)
209 self.failUnlessIn("Alias names cannot contain spaces.", stderr)
213 def test_create_invite_join(self):
214 self.basedir = "cli/MagicFolder/create-invite-join"
216 local_dir = os.path.join(self.basedir, "magic")
217 abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
219 d = self.do_cli("magic-folder", "create", "magic:", "Alice", local_dir)
220 def _done((rc, stdout, stderr)):
221 self.failUnlessEqual(rc, 0)
222 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
224 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
225 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
228 def test_create_invite_join_failure(self):
229 self.basedir = "cli/MagicFolder/create-invite-join-failure"
230 os.makedirs(self.basedir)
232 o = magic_folder_cli.CreateOptions()
233 o.parent = magic_folder_cli.MagicFolderCommand()
234 o.parent['node-directory'] = self.basedir
236 o.parseArgs("magic:", "Alice", "-foo")
237 except usage.UsageError as e:
238 self.failUnlessIn("cannot start with '-'", str(e))
240 self.fail("expected UsageError")
242 def test_join_failure(self):
243 self.basedir = "cli/MagicFolder/create-join-failure"
244 os.makedirs(self.basedir)
246 o = magic_folder_cli.JoinOptions()
247 o.parent = magic_folder_cli.MagicFolderCommand()
248 o.parent['node-directory'] = self.basedir
250 o.parseArgs("URI:invite+URI:code", "-foo")
251 except usage.UsageError as e:
252 self.failUnlessIn("cannot start with '-'", str(e))
254 self.fail("expected UsageError")
256 def test_join_twice_failure(self):
257 self.basedir = "cli/MagicFolder/create-join-twice-failure"
258 os.makedirs(self.basedir)
260 local_dir = os.path.join(self.basedir, "magic")
261 abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
263 d = self.do_create_magic_folder(0)
264 d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
265 def get_invite_code_and_join((rc, stdout, stderr)):
266 self.invite_code = stdout.strip()
267 return self.do_join(0, unicode(local_dir), self.invite_code)
268 d.addCallback(get_invite_code_and_join)
270 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
271 d.addCallback(get_caps)
272 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
273 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
274 def join_again(ignore):
275 return self.do_cli("magic-folder", "join", self.invite_code, local_dir, client_num=0)
276 d.addCallback(join_again)
277 def get_results(result):
281 self.failUnlessEqual(stdout, "")
282 self.failUnlessEqual(stderr, "\nThis client has already joined a magic folder."
283 "\nUse the 'tahoe magic-folder leave' command first.\n\n")
284 self.failIfEqual(code, 0)
285 d.addCallback(get_results)
288 def test_join_leave_join(self):
289 self.basedir = "cli/MagicFolder/create-join-leave-join"
290 os.makedirs(self.basedir)
292 local_dir = os.path.join(self.basedir, "magic")
293 abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
295 self.invite_code = None
296 d = self.do_create_magic_folder(0)
297 d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
298 def get_invite_code_and_join((rc, stdout, stderr)):
299 self.invite_code = stdout.strip()
300 return self.do_join(0, unicode(local_dir), self.invite_code)
301 d.addCallback(get_invite_code_and_join)
303 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
304 d.addCallback(get_caps)
305 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
306 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
307 d.addCallback(lambda ign: self.do_leave(0))
309 def check_join_again(invite_code):
310 d2 = defer.succeed(None)
311 def join_again(ignore):
312 return self.do_join(0, unicode(local_dir), self.invite_code)
313 d2.addCallback(join_again)
316 d.addCallback(lambda ign, invite_code: check_join_again(invite_code), self.invite_code)
318 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
319 d.addCallback(get_caps)
320 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
321 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
325 def test_join_failures(self):
326 self.basedir = "cli/MagicFolder/create-join-failures"
327 os.makedirs(self.basedir)
329 local_dir = os.path.join(self.basedir, "magic")
330 abs_local_dir_u = abspath_expanduser_unicode(unicode(local_dir), long_path=False)
332 self.invite_code = None
333 d = self.do_create_magic_folder(0)
334 d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
335 def get_invite_code_and_join((rc, stdout, stderr)):
336 self.invite_code = stdout.strip()
337 return self.do_join(0, unicode(local_dir), self.invite_code)
338 d.addCallback(get_invite_code_and_join)
340 self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
341 d.addCallback(get_caps)
342 d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
343 d.addCallback(lambda ign: self.check_config(0, abs_local_dir_u))
346 return self.do_cli("magic-folder", "leave", client_num=0)
349 collective_dircap_file = os.path.join(self.get_clientdir(i=0), u"private", u"collective_dircap")
350 upload_dircap = os.path.join(self.get_clientdir(i=0), u"private", u"magic_folder_dircap")
351 magic_folder_db_file = os.path.join(self.get_clientdir(i=0), u"private", u"magicfolderdb.sqlite")
353 def check_join_if_file(my_file):
354 fileutil.write(my_file, "my file data")
355 d2 = defer.succeed(None)
356 def join_again(ignore):
357 return self.do_cli("magic-folder", "join", self.invite_code, local_dir, client_num=0)
358 d2.addCallback(join_again)
359 def get_results(result):
361 self.failIfEqual(code, 0)
362 d2.addCallback(get_results)
365 for my_file in [collective_dircap_file, upload_dircap, magic_folder_db_file]:
366 d.addCallback(lambda ign, my_file: check_join_if_file(my_file), my_file)