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