src/allmydata/test/test_cli_magic_folder.py

   1 import os.path
   2 import re
   3
   4 from twisted.trial import unittest
   5 from twisted.internet import defer
   6 from twisted.internet import reactor
   7 from twisted.python import usage
   8
   9 from allmydata.util.assertutil import precondition
  10 from allmydata.util import fileutil
  11 from allmydata.util.fileutil import precondition_abspath
  12 from allmydata.scripts.common import get_aliases
  13 from allmydata.test.no_network import GridTestMixin
  14 from .test_cli import CLITestMixin
  15 from allmydata.scripts import magic_folder_cli
  16 from allmydata.util.fileutil import abspath_expanduser_unicode
  17 from allmydata.util.encodingutil import unicode_to_argv
  18 from allmydata.frontends.magic_folder import MagicFolder
  19 from allmydata import uri
  20
  21
  22 class MagicFolderCLITestMixin(CLITestMixin, GridTestMixin):
  23     def do_create_magic_folder(self, client_num):
  24         d = self.do_cli("magic-folder", "create", "magic:", client_num=client_num)
  25         def _done((rc,stdout,stderr)):
  26             self.failUnlessEqual(rc, 0)
  27             self.failUnlessIn("Alias 'magic' created", stdout)
  28             self.failUnlessEqual(stderr, "")
  29             aliases = get_aliases(self.get_clientdir(i=client_num))
  30             self.failUnlessIn("magic", aliases)
  31             self.failUnless(aliases["magic"].startswith("URI:DIR2:"))
  32         d.addCallback(_done)
  33         return d
  34
  35     def do_invite(self, client_num, nickname):
  36         nickname_arg = unicode_to_argv(nickname)
  37         d = self.do_cli("magic-folder", "invite", "magic:", nickname_arg, client_num=client_num)
  38         def _done((rc, stdout, stderr)):
  39             self.failUnlessEqual(rc, 0)
  40             return (rc, stdout, stderr)
  41         d.addCallback(_done)
  42         return d
  43
  44     def do_join(self, client_num, local_dir, invite_code):
  45         precondition(isinstance(local_dir, unicode), local_dir=local_dir)
  46         precondition(isinstance(invite_code, str), invite_code=invite_code)
  47
  48         local_dir_arg = unicode_to_argv(local_dir)
  49         d = self.do_cli("magic-folder", "join", invite_code, local_dir_arg, client_num=client_num)
  50         def _done((rc, stdout, stderr)):
  51             self.failUnlessEqual(rc, 0)
  52             return (rc, stdout, stderr)
  53         d.addCallback(_done)
  54         return d
  55
  56     def check_joined_config(self, client_num, upload_dircap):
  57         """Tests that our collective directory has the readonly cap of
  58         our upload directory.
  59         """
  60         collective_readonly_cap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  61                                                              u"private", u"collective_dircap"))
  62         d = self.do_cli("ls", "--json", collective_readonly_cap, client_num=client_num)
  63         def _done((rc, stdout, stderr)):
  64             self.failUnlessEqual(rc, 0)
  65             return (rc, stdout, stderr)
  66         d.addCallback(_done)
  67         def test_joined_magic_folder((rc,stdout,stderr)):
  68             readonly_cap = unicode(uri.from_string(upload_dircap).get_readonly().to_string(), 'utf-8')
  69             s = re.search(readonly_cap, stdout)
  70             self.failUnless(s is not None)
  71             return None
  72         d.addCallback(test_joined_magic_folder)
  73         return d
  74
  75     def get_caps_from_files(self, client_num):
  76         collective_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  77                                                        u"private", u"collective_dircap"))
  78         upload_dircap = fileutil.read(os.path.join(self.get_clientdir(i=client_num),
  79                                                    u"private", u"magic_folder_dircap"))
  80         self.failIf(collective_dircap is None or upload_dircap is None)
  81         return collective_dircap, upload_dircap
  82
  83     def check_config(self, client_num, local_dir):
  84         precondition_abspath(local_dir)
  85         client_config = fileutil.read(os.path.join(self.get_clientdir(i=client_num), "tahoe.cfg"))
  86         local_dir_utf8 = local_dir.encode('utf-8')
  87         ret = re.search("\[magic_folder\]\nenabled = True\nlocal.directory = %s" % (local_dir_utf8,), client_config)
  88         self.failIf(ret is None)
  89
  90     def create_invite_join_magic_folder(self, nickname, local_dir):
  91         nickname_arg = unicode_to_argv(nickname)
  92         local_dir_arg = unicode_to_argv(local_dir)
  93         d = self.do_cli("magic-folder", "create", "magic:", nickname_arg, local_dir_arg)
  94         def _done((rc, stdout, stderr)):
  95             self.failUnlessEqual(rc, 0)
  96
  97             client = self.get_client()
  98             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
  99             self.collective_dirnode = client.create_node_from_uri(self.collective_dircap)
 100             self.upload_dirnode     = client.create_node_from_uri(self.upload_dircap)
 101         d.addCallback(_done)
 102         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 103         d.addCallback(lambda ign: self.check_config(0, local_dir))
 104         return d
 105
 106     def cleanup(self, res):
 107         #print "cleanup", res
 108         d = defer.succeed(None)
 109         if self.magicfolder is not None:
 110             d.addCallback(lambda ign: self.magicfolder.finish())
 111         d.addCallback(lambda ign: res)
 112         return d
 113
 114     def init_magicfolder(self, client_num, upload_dircap, collective_dircap, local_magic_dir, clock):
 115         dbfile = abspath_expanduser_unicode(u"magicfolderdb.sqlite", base=self.get_clientdir(i=client_num))
 116         magicfolder = MagicFolder(self.get_client(client_num), upload_dircap, collective_dircap, local_magic_dir,
 117                                        dbfile, pending_delay=0.2, clock=clock)
 118         magicfolder.downloader._turn_delay = 0
 119
 120         orig = magicfolder.uploader._append_to_deque
 121         # the _append_to_deque method queues a _turn_deque, so we
 122         # immediately trigger it by wrapping _append_to_deque
 123         def wrap(*args, **kw):
 124             x = orig(*args, **kw)
 125             clock.advance(0)  # _turn_delay is always 0 for the tests
 126             return x
 127         magicfolder.uploader._append_to_deque = wrap
 128
 129         magicfolder.setServiceParent(self.get_client(client_num))
 130         magicfolder.ready()
 131         return magicfolder
 132
 133     def setup_alice_and_bob(self, alice_clock=reactor, bob_clock=reactor):
 134         self.set_up_grid(num_clients=2)
 135
 136         self.alice_magicfolder = None
 137         self.bob_magicfolder = None
 138
 139         alice_magic_dir = abspath_expanduser_unicode(u"Alice-magic", base=self.basedir)
 140         self.mkdir_nonascii(alice_magic_dir)
 141         bob_magic_dir = abspath_expanduser_unicode(u"Bob-magic", base=self.basedir)
 142         self.mkdir_nonascii(bob_magic_dir)
 143
 144         # Alice creates a Magic Folder,
 145         # invites herself then and joins.
 146         d = self.do_create_magic_folder(0)
 147         d.addCallback(lambda ign: self.do_invite(0, u"Alice\u00F8"))
 148         def get_invite_code(result):
 149             self.invite_code = result[1].strip()
 150         d.addCallback(get_invite_code)
 151         d.addCallback(lambda ign: self.do_join(0, alice_magic_dir, self.invite_code))
 152         def get_alice_caps(ign):
 153             self.alice_collective_dircap, self.alice_upload_dircap = self.get_caps_from_files(0)
 154         d.addCallback(get_alice_caps)
 155         d.addCallback(lambda ign: self.check_joined_config(0, self.alice_upload_dircap))
 156         d.addCallback(lambda ign: self.check_config(0, alice_magic_dir))
 157         def get_Alice_magicfolder(result):
 158             self.alice_magicfolder = self.init_magicfolder(0, self.alice_upload_dircap,
 159                                                            self.alice_collective_dircap,
 160                                                            alice_magic_dir, alice_clock)
 161             return result
 162         d.addCallback(get_Alice_magicfolder)
 163
 164         # Alice invites Bob. Bob joins.
 165         d.addCallback(lambda ign: self.do_invite(0, u"Bob\u00F8"))
 166         def get_invite_code(result):
 167             self.invite_code = result[1].strip()
 168         d.addCallback(get_invite_code)
 169         d.addCallback(lambda ign: self.do_join(1, bob_magic_dir, self.invite_code))
 170         def get_bob_caps(ign):
 171             self.bob_collective_dircap, self.bob_upload_dircap = self.get_caps_from_files(1)
 172         d.addCallback(get_bob_caps)
 173         d.addCallback(lambda ign: self.check_joined_config(1, self.bob_upload_dircap))
 174         d.addCallback(lambda ign: self.check_config(1, bob_magic_dir))
 175         def get_Bob_magicfolder(result):
 176             self.bob_magicfolder = self.init_magicfolder(1, self.bob_upload_dircap,
 177                                                          self.bob_collective_dircap,
 178                                                          bob_magic_dir, bob_clock)
 179             return result
 180         d.addCallback(get_Bob_magicfolder)
 181         return d
 182
 183
 184 class CreateMagicFolder(MagicFolderCLITestMixin, unittest.TestCase):
 185     def test_create_and_then_invite_join(self):
 186         self.basedir = "cli/MagicFolder/create-and-then-invite-join"
 187         self.set_up_grid()
 188         local_dir = os.path.join(self.basedir, "magic")
 189
 190         d = self.do_create_magic_folder(0)
 191         d.addCallback(lambda ign: self.do_invite(0, u"Alice"))
 192         def get_invite_code_and_join((rc, stdout, stderr)):
 193             invite_code = stdout.strip()
 194             return self.do_join(0, unicode(local_dir), invite_code)
 195         d.addCallback(get_invite_code_and_join)
 196         def get_caps(ign):
 197             self.collective_dircap, self.upload_dircap = self.get_caps_from_files(0)
 198         d.addCallback(get_caps)
 199         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 200         d.addCallback(lambda ign: self.check_config(0, abspath_expanduser_unicode(unicode(local_dir))))
 201         return d
 202
 203     def test_create_error(self):
 204         self.basedir = "cli/MagicFolder/create-error"
 205         self.set_up_grid()
 206
 207         d = self.do_cli("magic-folder", "create", "m a g i c:", client_num=0)
 208         def _done((rc, stdout, stderr)):
 209             self.failIfEqual(rc, 0)
 210             self.failUnlessIn("Alias names cannot contain spaces.", stderr)
 211         d.addCallback(_done)
 212         return d
 213
 214     def test_create_invite_join(self):
 215         self.basedir = "cli/MagicFolder/create-invite-join"
 216         self.set_up_grid()
 217         local_dir = os.path.join(self.basedir, "magic")
 218
 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)
 223         d.addCallback(_done)
 224         d.addCallback(lambda ign: self.check_joined_config(0, self.upload_dircap))
 225         d.addCallback(lambda ign: self.check_config(0, abspath_expanduser_unicode(unicode(local_dir))))
 226         return d
 227
 228     def test_create_invite_join_failure(self):
 229         self.basedir = "cli/MagicFolder/create-invite-join-failure"
 230         os.makedirs(self.basedir)
 231
 232         o = magic_folder_cli.CreateOptions()
 233         o.parent = magic_folder_cli.MagicFolderCommand()
 234         o.parent['node-directory'] = self.basedir
 235         try:
 236             o.parseArgs("magic:", "Alice", "-foo")
 237         except usage.UsageError as e:
 238             self.failUnlessIn("cannot start with '-'", str(e))
 239         else:
 240             self.fail("expected UsageError")
 241
 242     def test_join_failure(self):
 243         self.basedir = "cli/MagicFolder/create-join-failure"
 244         os.makedirs(self.basedir)
 245
 246         o = magic_folder_cli.JoinOptions()
 247         o.parent = magic_folder_cli.MagicFolderCommand()
 248         o.parent['node-directory'] = self.basedir
 249         try:
 250             o.parseArgs("URI:invite+URI:code", "-foo")
 251         except usage.UsageError as e:
 252             self.failUnlessIn("cannot start with '-'", str(e))
 253         else:
 254             self.fail("expected UsageError")