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