src/allmydata/test/test_sftp.py

   1
   2 import re
   3 from stat import S_IFREG, S_IFDIR
   4
   5 from twisted.trial import unittest
   6 from twisted.internet import defer
   7 from twisted.python.failure import Failure
   8 from twisted.internet.error import ProcessDone, ProcessTerminated
   9
  10 conch_interfaces = None
  11 sftp = None
  12 sftpd = None
  13 have_pycrypto = False
  14 try:
  15     from Crypto import Util
  16     Util  # hush pyflakes
  17     have_pycrypto = True
  18 except ImportError:
  19     pass
  20
  21 if have_pycrypto:
  22     from twisted.conch import interfaces as conch_interfaces
  23     from twisted.conch.ssh import filetransfer as sftp
  24     from allmydata.frontends import sftpd
  25
  26 import traceback
  27
  28 """
  29 import sys
  30 def trace_exceptions(frame, event, arg):
  31     if event != 'exception':
  32         return
  33     co = frame.f_code
  34     func_name = co.co_name
  35     line_no = frame.f_lineno
  36     filename = co.co_filename
  37     exc_type, exc_value, exc_traceback = arg
  38     print 'Tracing exception: %r %r on line %r of %r in %r' % \
  39         (exc_type.__name__, exc_value, line_no, func_name, filename)
  40
  41 def trace_calls(frame, event, arg):
  42     if event != 'call':
  43         return
  44     return trace_exceptions
  45
  46 sys.settrace(trace_calls)
  47 """
  48
  49 timeout = 30
  50
  51 from allmydata.interfaces import IDirectoryNode, ExistingChildError, NoSuchChildError
  52 from allmydata.mutable.common import NotWriteableError
  53
  54 from allmydata.util.consumer import download_to_data
  55 from allmydata.immutable import upload
  56 from allmydata.test.no_network import GridTestMixin
  57 from allmydata.test.common import ShouldFailMixin
  58
  59 class Handler(GridTestMixin, ShouldFailMixin, unittest.TestCase):
  60     """This is a no-network unit test of the SFTPHandler class."""
  61
  62     if not have_pycrypto:
  63         skip = "SFTP support requires pycrypto, which is not installed"
  64
  65     def shouldFailWithSFTPError(self, expected_code, which, callable, *args, **kwargs):
  66         assert isinstance(expected_code, int), repr(expected_code)
  67         assert isinstance(which, str), repr(which)
  68         s = traceback.format_stack()
  69         d = defer.maybeDeferred(callable, *args, **kwargs)
  70         def _done(res):
  71             if isinstance(res, Failure):
  72                 res.trap(sftp.SFTPError)
  73                 self.failUnlessReallyEqual(res.value.code, expected_code,
  74                                          "%s was supposed to raise SFTPError(%d), not SFTPError(%d): %s" %
  75                                          (which, expected_code, res.value.code, res))
  76             else:
  77                 print '@' + '@'.join(s)
  78                 self.fail("%s was supposed to raise SFTPError(%d), not get '%s'" %
  79                           (which, expected_code, res))
  80         d.addBoth(_done)
  81         return d
  82
  83     def failUnlessReallyEqual(self, a, b, msg=None):
  84         self.failUnlessEqual(a, b, msg=msg)
  85         self.failUnlessEqual(type(a), type(b), msg=msg)
  86
  87     def _set_up(self, basedir, num_clients=1, num_servers=10):
  88         self.basedir = "sftp/" + basedir
  89         self.set_up_grid(num_clients=num_clients, num_servers=num_servers)
  90
  91         self.client = self.g.clients[0]
  92         self.username = "alice"
  93
  94         d = self.client.create_dirnode()
  95         def _created_root(node):
  96             self.root = node
  97             self.root_uri = node.get_uri()
  98             self.handler = sftpd.SFTPUserHandler(self.client, self.root, self.username)
  99         d.addCallback(_created_root)
 100         return d
 101
 102     def _set_up_tree(self):
 103         d = self.client.create_mutable_file("mutable file contents")
 104         d.addCallback(lambda node: self.root.set_node(u"mutable", node))
 105         def _created_mutable(n):
 106             self.mutable = n
 107             self.mutable_uri = n.get_uri()
 108         d.addCallback(_created_mutable)
 109
 110         d.addCallback(lambda ign:
 111                       self.root._create_and_validate_node(None, self.mutable.get_readonly_uri(), name=u"readonly"))
 112         d.addCallback(lambda node: self.root.set_node(u"readonly", node))
 113         def _created_readonly(n):
 114             self.readonly = n
 115             self.readonly_uri = n.get_uri()
 116         d.addCallback(_created_readonly)
 117
 118         gross = upload.Data("0123456789" * 101, None)
 119         d.addCallback(lambda ign: self.root.add_file(u"gro\u00DF", gross))
 120         def _created_gross(n):
 121             self.gross = n
 122             self.gross_uri = n.get_uri()
 123         d.addCallback(_created_gross)
 124
 125         small = upload.Data("0123456789", None)
 126         d.addCallback(lambda ign: self.root.add_file(u"small", small))
 127         def _created_small(n):
 128             self.small = n
 129             self.small_uri = n.get_uri()
 130         d.addCallback(_created_small)
 131
 132         small2 = upload.Data("Small enough for a LIT too", None)
 133         d.addCallback(lambda ign: self.root.add_file(u"small2", small2))
 134         def _created_small2(n):
 135             self.small2 = n
 136             self.small2_uri = n.get_uri()
 137         d.addCallback(_created_small2)
 138
 139         empty_litdir_uri = "URI:DIR2-LIT:"
 140
 141         # contains one child which is itself also LIT:
 142         tiny_litdir_uri = "URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdgnz5hgyzufqydulbshj5x2lbm"
 143
 144         unknown_uri = "x-tahoe-crazy://I_am_from_the_future."
 145
 146         d.addCallback(lambda ign: self.root._create_and_validate_node(None, empty_litdir_uri, name=u"empty_lit_dir"))
 147         def _created_empty_lit_dir(n):
 148             self.empty_lit_dir = n
 149             self.empty_lit_dir_uri = n.get_uri()
 150             self.root.set_node(u"empty_lit_dir", n)
 151         d.addCallback(_created_empty_lit_dir)
 152
 153         d.addCallback(lambda ign: self.root._create_and_validate_node(None, tiny_litdir_uri, name=u"tiny_lit_dir"))
 154         def _created_tiny_lit_dir(n):
 155             self.tiny_lit_dir = n
 156             self.tiny_lit_dir_uri = n.get_uri()
 157             self.root.set_node(u"tiny_lit_dir", n)
 158         d.addCallback(_created_tiny_lit_dir)
 159
 160         d.addCallback(lambda ign: self.root._create_and_validate_node(None, unknown_uri, name=u"unknown"))
 161         def _created_unknown(n):
 162             self.unknown = n
 163             self.unknown_uri = n.get_uri()
 164             self.root.set_node(u"unknown", n)
 165         d.addCallback(_created_unknown)
 166
 167         d.addCallback(lambda ign: self.root.set_node(u"loop", self.root))
 168         return d
 169
 170     def test_basic(self):
 171         d = self._set_up("basic")
 172         def _check(ign):
 173             # Test operations that have no side-effects, and don't need the tree.
 174
 175             version = self.handler.gotVersion(3, {})
 176             self.failUnless(isinstance(version, dict))
 177
 178             self.failUnlessReallyEqual(self.handler._path_from_string(""), [])
 179             self.failUnlessReallyEqual(self.handler._path_from_string("/"), [])
 180             self.failUnlessReallyEqual(self.handler._path_from_string("."), [])
 181             self.failUnlessReallyEqual(self.handler._path_from_string("//"), [])
 182             self.failUnlessReallyEqual(self.handler._path_from_string("/."), [])
 183             self.failUnlessReallyEqual(self.handler._path_from_string("/./"), [])
 184             self.failUnlessReallyEqual(self.handler._path_from_string("foo"), [u"foo"])
 185             self.failUnlessReallyEqual(self.handler._path_from_string("/foo"), [u"foo"])
 186             self.failUnlessReallyEqual(self.handler._path_from_string("foo/"), [u"foo"])
 187             self.failUnlessReallyEqual(self.handler._path_from_string("/foo/"), [u"foo"])
 188             self.failUnlessReallyEqual(self.handler._path_from_string("foo/bar"), [u"foo", u"bar"])
 189             self.failUnlessReallyEqual(self.handler._path_from_string("/foo/bar"), [u"foo", u"bar"])
 190             self.failUnlessReallyEqual(self.handler._path_from_string("foo/bar//"), [u"foo", u"bar"])
 191             self.failUnlessReallyEqual(self.handler._path_from_string("/foo/bar//"), [u"foo", u"bar"])
 192             self.failUnlessReallyEqual(self.handler._path_from_string("foo/../bar"), [u"bar"])
 193             self.failUnlessReallyEqual(self.handler._path_from_string("/foo/../bar"), [u"bar"])
 194             self.failUnlessReallyEqual(self.handler._path_from_string("../bar"), [u"bar"])
 195             self.failUnlessReallyEqual(self.handler._path_from_string("/../bar"), [u"bar"])
 196
 197             self.failUnlessReallyEqual(self.handler.realPath(""), "/")
 198             self.failUnlessReallyEqual(self.handler.realPath("/"), "/")
 199             self.failUnlessReallyEqual(self.handler.realPath("."), "/")
 200             self.failUnlessReallyEqual(self.handler.realPath("//"), "/")
 201             self.failUnlessReallyEqual(self.handler.realPath("/."), "/")
 202             self.failUnlessReallyEqual(self.handler.realPath("/./"), "/")
 203             self.failUnlessReallyEqual(self.handler.realPath("foo"), "/foo")
 204             self.failUnlessReallyEqual(self.handler.realPath("/foo"), "/foo")
 205             self.failUnlessReallyEqual(self.handler.realPath("foo/"), "/foo")
 206             self.failUnlessReallyEqual(self.handler.realPath("/foo/"), "/foo")
 207             self.failUnlessReallyEqual(self.handler.realPath("foo/bar"), "/foo/bar")
 208             self.failUnlessReallyEqual(self.handler.realPath("/foo/bar"), "/foo/bar")
 209             self.failUnlessReallyEqual(self.handler.realPath("foo/bar//"), "/foo/bar")
 210             self.failUnlessReallyEqual(self.handler.realPath("/foo/bar//"), "/foo/bar")
 211             self.failUnlessReallyEqual(self.handler.realPath("foo/../bar"), "/bar")
 212             self.failUnlessReallyEqual(self.handler.realPath("/foo/../bar"), "/bar")
 213             self.failUnlessReallyEqual(self.handler.realPath("../bar"), "/bar")
 214             self.failUnlessReallyEqual(self.handler.realPath("/../bar"), "/bar")
 215         d.addCallback(_check)
 216
 217         d.addCallback(lambda ign:
 218             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_path_from_string invalid UTF-8",
 219                                          self.handler._path_from_string, "\xFF"))
 220         d.addCallback(lambda ign:
 221             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "realPath invalid UTF-8",
 222                                          self.handler.realPath, "\xFF"))
 223
 224         return d
 225
 226     def test_raise_error(self):
 227         self.failUnlessReallyEqual(sftpd._raise_error(None), None)
 228
 229         d = defer.succeed(None)
 230         d.addCallback(lambda ign:
 231             self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_raise_error SFTPError",
 232                                          sftpd._raise_error, Failure(sftp.SFTPError(sftp.FX_FAILURE, "foo"))))
 233         d.addCallback(lambda ign:
 234             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "_raise_error NoSuchChildError",
 235                                          sftpd._raise_error, Failure(NoSuchChildError("foo"))))
 236         d.addCallback(lambda ign:
 237             self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_raise_error ExistingChildError",
 238                                          sftpd._raise_error, Failure(ExistingChildError("foo"))))
 239         d.addCallback(lambda ign:
 240             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "_raise_error NotWriteableError",
 241                                          sftpd._raise_error, Failure(NotWriteableError("foo"))))
 242         d.addCallback(lambda ign:
 243             self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "_raise_error NotImplementedError",
 244                                          sftpd._raise_error, Failure(NotImplementedError("foo"))))
 245         d.addCallback(lambda ign:
 246             self.shouldFailWithSFTPError(sftp.FX_EOF, "_raise_error EOFError",
 247                                          sftpd._raise_error, Failure(EOFError("foo"))))
 248         d.addCallback(lambda ign:
 249             self.shouldFailWithSFTPError(sftp.FX_EOF, "_raise_error defer.FirstError",
 250                                          sftpd._raise_error, Failure(defer.FirstError(
 251                                                                Failure(sftp.SFTPError(sftp.FX_EOF, "foo")), 0))))
 252         d.addCallback(lambda ign:
 253             self.shouldFailWithSFTPError(sftp.FX_FAILURE, "_raise_error AssertionError",
 254                                          sftpd._raise_error, Failure(AssertionError("foo"))))
 255
 256         return d
 257
 258     def test_not_implemented(self):
 259         d = self._set_up("not_implemented")
 260
 261         d.addCallback(lambda ign:
 262             self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "readLink link",
 263                                          self.handler.readLink, "link"))
 264         d.addCallback(lambda ign:
 265             self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "makeLink link file",
 266                                          self.handler.makeLink, "link", "file"))
 267
 268         return d
 269
 270     def _compareDirLists(self, actual, expected):
 271        actual_list = sorted(actual)
 272        expected_list = sorted(expected)
 273        self.failUnlessReallyEqual(len(actual_list), len(expected_list),
 274                             "%r is wrong length, expecting %r" % (actual_list, expected_list))
 275        for (a, b) in zip(actual_list, expected_list):
 276            (name, text, attrs) = a
 277            (expected_name, expected_text_re, expected_attrs) = b
 278            self.failUnlessReallyEqual(name, expected_name)
 279            self.failUnless(re.match(expected_text_re, text), "%r does not match %r" % (text, expected_text_re))
 280            # it is ok for there to be extra actual attributes
 281            # TODO: check times
 282            for e in expected_attrs:
 283                self.failUnlessReallyEqual(attrs[e], expected_attrs[e])
 284
 285     def test_openDirectory_and_attrs(self):
 286         d = self._set_up("openDirectory_and_attrs")
 287         d.addCallback(lambda ign: self._set_up_tree())
 288
 289         d.addCallback(lambda ign:
 290             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory small",
 291                                          self.handler.openDirectory, "small"))
 292         d.addCallback(lambda ign:
 293             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openDirectory unknown",
 294                                          self.handler.openDirectory, "unknown"))
 295         d.addCallback(lambda ign:
 296             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir",
 297                                          self.handler.openDirectory, "nodir"))
 298         d.addCallback(lambda ign:
 299             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openDirectory nodir/nodir",
 300                                          self.handler.openDirectory, "nodir/nodir"))
 301
 302         gross = u"gro\u00DF".encode("utf-8")
 303         expected_root = [
 304             ('empty_lit_dir', r'drwxrwx--- .* \? .* empty_lit_dir$', {'permissions': S_IFDIR | 0770}),
 305             (gross,           r'-rw-rw---- .* 1010 .* '+gross+'$',   {'permissions': S_IFREG | 0660, 'size': 1010}),
 306             ('loop',          r'drwxrwx--- .* \? .* loop$',          {'permissions': S_IFDIR | 0770}),
 307             ('mutable',       r'-rw-rw---- .* \? .* mutable$',       {'permissions': S_IFREG | 0660}),
 308             ('readonly',      r'-r--r----- .* \? .* readonly$',      {'permissions': S_IFREG | 0440}),
 309             ('small',         r'-rw-rw---- .* 10 .* small$',         {'permissions': S_IFREG | 0660, 'size': 10}),
 310             ('small2',        r'-rw-rw---- .* 26 .* small2$',        {'permissions': S_IFREG | 0660, 'size': 26}),
 311             ('tiny_lit_dir',  r'drwxrwx--- .* \? .* tiny_lit_dir$',  {'permissions': S_IFDIR | 0770}),
 312             ('unknown',       r'\?--------- .* \? .* unknown$',      {'permissions': 0}),
 313         ]
 314
 315         d.addCallback(lambda ign: self.handler.openDirectory(""))
 316         d.addCallback(lambda res: self._compareDirLists(res, expected_root))
 317
 318         d.addCallback(lambda ign: self.handler.openDirectory("loop"))
 319         d.addCallback(lambda res: self._compareDirLists(res, expected_root))
 320
 321         d.addCallback(lambda ign: self.handler.openDirectory("loop/loop"))
 322         d.addCallback(lambda res: self._compareDirLists(res, expected_root))
 323
 324         d.addCallback(lambda ign: self.handler.openDirectory("empty_lit_dir"))
 325         d.addCallback(lambda res: self._compareDirLists(res, []))
 326
 327         expected_tiny_lit = [
 328             ('short', r'-r--r----- .* 8 Jan 01  1970 short$', {'permissions': S_IFREG | 0440, 'size': 8}),
 329         ]
 330
 331         d.addCallback(lambda ign: self.handler.openDirectory("tiny_lit_dir"))
 332         d.addCallback(lambda res: self._compareDirLists(res, expected_tiny_lit))
 333
 334         d.addCallback(lambda ign: self.handler.getAttrs("small", True))
 335         def _check_attrs(attrs):
 336             self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
 337             self.failUnlessReallyEqual(attrs['size'], 10)
 338         d.addCallback(_check_attrs)
 339
 340         d.addCallback(lambda ign:
 341             self.failUnlessReallyEqual(self.handler.setAttrs("small", {}), None))
 342
 343         d.addCallback(lambda ign:
 344             self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "setAttrs size",
 345                                          self.handler.setAttrs, "small", {'size': 0}))
 346
 347         return d
 348
 349     def test_openFile_read(self):
 350         d = self._set_up("openFile_read")
 351         d.addCallback(lambda ign: self._set_up_tree())
 352
 353         d.addCallback(lambda ign:
 354             self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small 0",
 355                                          self.handler.openFile, "small", 0, {}))
 356
 357         # attempting to open a non-existent file should fail
 358         d.addCallback(lambda ign:
 359             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nofile READ",
 360                                          self.handler.openFile, "nofile", sftp.FXF_READ, {}))
 361         d.addCallback(lambda ign:
 362             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile nodir/file READ",
 363                                          self.handler.openFile, "nodir/file", sftp.FXF_READ, {}))
 364
 365         d.addCallback(lambda ign:
 366             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown READ denied",
 367                                          self.handler.openFile, "unknown", sftp.FXF_READ, {}))
 368         d.addCallback(lambda ign:
 369             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir READ denied",
 370                                          self.handler.openFile, "tiny_lit_dir", sftp.FXF_READ, {}))
 371         d.addCallback(lambda ign:
 372             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown uri READ denied",
 373                                          self.handler.openFile, "uri/"+self.unknown_uri, sftp.FXF_READ, {}))
 374         d.addCallback(lambda ign:
 375             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir uri READ denied",
 376                                          self.handler.openFile, "uri/"+self.tiny_lit_dir_uri, sftp.FXF_READ, {}))
 377         # FIXME: should be FX_NO_SUCH_FILE?
 378         d.addCallback(lambda ign:
 379             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile noexist uri READ denied",
 380                                          self.handler.openFile, "uri/URI:noexist", sftp.FXF_READ, {}))
 381         d.addCallback(lambda ign:
 382             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile invalid UTF-8 uri READ denied",
 383                                          self.handler.openFile, "uri/URI:\xFF", sftp.FXF_READ, {}))
 384
 385         # reading an existing file should succeed
 386         d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
 387         def _read_small(rf):
 388             d2 = rf.readChunk(0, 10)
 389             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 390
 391             d2.addCallback(lambda ign: rf.readChunk(2, 6))
 392             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "234567"))
 393
 394             d2.addCallback(lambda ign: rf.readChunk(8, 4))  # read that starts before EOF is OK
 395             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "89"))
 396
 397             d2.addCallback(lambda ign:
 398                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
 399                                              rf.readChunk, 10, 0))
 400             d2.addCallback(lambda ign:
 401                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
 402                                              rf.readChunk, 10, 1))
 403             d2.addCallback(lambda ign:
 404                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
 405                                              rf.readChunk, 11, 1))
 406
 407             d2.addCallback(lambda ign: rf.getAttrs())
 408             def _check_attrs(attrs):
 409                 self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
 410                 self.failUnlessReallyEqual(attrs['size'], 10)
 411             d2.addCallback(_check_attrs)
 412
 413             d2.addCallback(lambda ign:
 414                 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
 415                                              rf.writeChunk, 0, "a"))
 416             d2.addCallback(lambda ign:
 417                 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
 418                                              rf.setAttrs, {}))
 419
 420             d2.addCallback(lambda ign: rf.close())
 421
 422             d2.addCallback(lambda ign:
 423                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file",
 424                                              rf.readChunk, 0, 1))
 425             d2.addCallback(lambda ign:
 426                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file",
 427                                              rf.getAttrs))
 428
 429             d2.addCallback(lambda ign: rf.close()) # should be no-op
 430             return d2
 431         d.addCallback(_read_small)
 432
 433         # repeat for a large file
 434         gross = u"gro\u00DF".encode("utf-8")
 435         d.addCallback(lambda ign: self.handler.openFile(gross, sftp.FXF_READ, {}))
 436         def _read_gross(rf):
 437             d2 = rf.readChunk(0, 10)
 438             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 439
 440             d2.addCallback(lambda ign: rf.readChunk(2, 6))
 441             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "234567"))
 442
 443             d2.addCallback(lambda ign: rf.readChunk(1008, 4))  # read that starts before EOF is OK
 444             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "89"))
 445
 446             d2.addCallback(lambda ign:
 447                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF (0-byte)",
 448                                              rf.readChunk, 1010, 0))
 449             d2.addCallback(lambda ign:
 450                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting at EOF",
 451                                              rf.readChunk, 1010, 1))
 452             d2.addCallback(lambda ign:
 453                 self.shouldFailWithSFTPError(sftp.FX_EOF, "readChunk starting after EOF",
 454                                              rf.readChunk, 1011, 1))
 455
 456             d2.addCallback(lambda ign: rf.getAttrs())
 457             def _check_attrs(attrs):
 458                 self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
 459                 self.failUnlessReallyEqual(attrs['size'], 1010)
 460             d2.addCallback(_check_attrs)
 461
 462             d2.addCallback(lambda ign:
 463                 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "writeChunk on read-only handle denied",
 464                                              rf.writeChunk, 0, "a"))
 465             d2.addCallback(lambda ign:
 466                 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "setAttrs on read-only handle denied",
 467                                              rf.setAttrs, {}))
 468
 469             d2.addCallback(lambda ign: rf.close())
 470
 471             d2.addCallback(lambda ign:
 472                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "readChunk on closed file",
 473                                              rf.readChunk, 0, 1))
 474             d2.addCallback(lambda ign:
 475                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "getAttrs on closed file",
 476                                              rf.getAttrs))
 477
 478             d2.addCallback(lambda ign: rf.close()) # should be no-op
 479             return d2
 480         d.addCallback(_read_gross)
 481
 482         # reading an existing small file via uri/ should succeed
 483         d.addCallback(lambda ign: self.handler.openFile("uri/"+self.small_uri, sftp.FXF_READ, {}))
 484         def _read_small_uri(rf):
 485             d2 = rf.readChunk(0, 10)
 486             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 487             d2.addCallback(lambda ign: rf.close())
 488             return d2
 489         d.addCallback(_read_small_uri)
 490
 491         # repeat for a large file
 492         d.addCallback(lambda ign: self.handler.openFile("uri/"+self.gross_uri, sftp.FXF_READ, {}))
 493         def _read_gross_uri(rf):
 494             d2 = rf.readChunk(0, 10)
 495             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 496             d2.addCallback(lambda ign: rf.close())
 497             return d2
 498         d.addCallback(_read_gross_uri)
 499
 500         # repeat for a mutable file
 501         d.addCallback(lambda ign: self.handler.openFile("uri/"+self.mutable_uri, sftp.FXF_READ, {}))
 502         def _read_mutable_uri(rf):
 503             d2 = rf.readChunk(0, 100)
 504             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable file contents"))
 505             d2.addCallback(lambda ign: rf.close())
 506             return d2
 507         d.addCallback(_read_mutable_uri)
 508
 509         # repeat for a file within a directory referenced by URI
 510         d.addCallback(lambda ign: self.handler.openFile("uri/"+self.tiny_lit_dir_uri+"/short", sftp.FXF_READ, {}))
 511         def _read_short(rf):
 512             d2 = rf.readChunk(0, 100)
 513             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "The end."))
 514             d2.addCallback(lambda ign: rf.close())
 515             return d2
 516         d.addCallback(_read_short)
 517
 518         return d
 519
 520     def test_openFile_write(self):
 521         d = self._set_up("openFile_write")
 522         d.addCallback(lambda ign: self._set_up_tree())
 523
 524         d.addCallback(lambda ign:
 525             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "openFile '' WRITE|CREAT|TRUNC",
 526                                          self.handler.openFile, "", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
 527         d.addCallback(lambda ign:
 528             self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile newfile WRITE|TRUNC",
 529                                          self.handler.openFile, "newfile", sftp.FXF_WRITE | sftp.FXF_TRUNC, {}))
 530         d.addCallback(lambda ign:
 531             self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "openFile small WRITE|EXCL",
 532                                          self.handler.openFile, "small", sftp.FXF_WRITE | sftp.FXF_EXCL, {}))
 533         d.addCallback(lambda ign:
 534             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir WRITE",
 535                                          self.handler.openFile, "tiny_lit_dir", sftp.FXF_WRITE, {}))
 536         d.addCallback(lambda ign:
 537             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile unknown WRITE",
 538                                          self.handler.openFile, "unknown", sftp.FXF_WRITE, {}))
 539         d.addCallback(lambda ign:
 540             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/newfile WRITE|CREAT|TRUNC",
 541                                          self.handler.openFile, "tiny_lit_dir/newfile",
 542                                          sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
 543         d.addCallback(lambda ign:
 544             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE",
 545                                          self.handler.openFile, "tiny_lit_dir/short", sftp.FXF_WRITE, {}))
 546         d.addCallback(lambda ign:
 547             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile tiny_lit_dir/short WRITE|CREAT|EXCL",
 548                                          self.handler.openFile, "tiny_lit_dir/short",
 549                                          sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
 550         d.addCallback(lambda ign:
 551             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly WRITE",
 552                                          self.handler.openFile, "readonly", sftp.FXF_WRITE, {}))
 553         d.addCallback(lambda ign:
 554             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small WRITE|CREAT|EXCL",
 555                                          self.handler.openFile, "small",
 556                                          sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
 557         d.addCallback(lambda ign:
 558             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile readonly uri WRITE",
 559                                          self.handler.openFile, "uri/"+self.readonly_uri, sftp.FXF_WRITE, {}))
 560         d.addCallback(lambda ign:
 561             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE",
 562                                          self.handler.openFile, "uri/"+self.small_uri, sftp.FXF_WRITE, {}))
 563         d.addCallback(lambda ign:
 564             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile small uri WRITE|CREAT|TRUNC",
 565                                          self.handler.openFile, "uri/"+self.small_uri,
 566                                          sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
 567         d.addCallback(lambda ign:
 568             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "openFile mutable uri WRITE|CREAT|EXCL",
 569                                          self.handler.openFile, "uri/"+self.mutable_uri,
 570                                          sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_EXCL, {}))
 571
 572         d.addCallback(lambda ign:
 573                       self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT | sftp.FXF_TRUNC, {}))
 574         def _write(wf):
 575             d2 = wf.writeChunk(0, "0123456789")
 576             d2.addCallback(lambda res: self.failUnlessReallyEqual(res, None))
 577
 578             d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
 579             d2.addCallback(lambda ign: wf.writeChunk(13, "abc"))
 580
 581             d2.addCallback(lambda ign: wf.getAttrs())
 582             def _check_attrs(attrs):
 583                 self.failUnlessReallyEqual(attrs['permissions'], S_IFREG | 0440) #FIXME
 584                 self.failUnlessReallyEqual(attrs['size'], 16)
 585             d2.addCallback(_check_attrs)
 586
 587             d2.addCallback(lambda ign: wf.setAttrs({}))
 588
 589             d2.addCallback(lambda ign:
 590                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs with negative size",
 591                                              wf.setAttrs, {'size': -1}))
 592
 593             d2.addCallback(lambda ign: wf.setAttrs({'size': 14}))
 594             d2.addCallback(lambda ign: wf.getAttrs())
 595             d2.addCallback(lambda attrs: self.failUnlessReallyEqual(attrs['size'], 14))
 596
 597             d2.addCallback(lambda ign:
 598                 self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "readChunk on write-only handle denied",
 599                                              wf.readChunk, 0, 1))
 600
 601             d2.addCallback(lambda ign: wf.close())
 602
 603             d2.addCallback(lambda ign:
 604                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "writeChunk on closed file",
 605                                              wf.writeChunk, 0, "a"))
 606             d2.addCallback(lambda ign:
 607                 self.shouldFailWithSFTPError(sftp.FX_BAD_MESSAGE, "setAttrs on closed file",
 608                                              wf.setAttrs, {'size': 0}))
 609
 610             d2.addCallback(lambda ign: wf.close()) # should be no-op
 611             return d2
 612         d.addCallback(_write)
 613         d.addCallback(lambda ign: self.root.get(u"newfile"))
 614         d.addCallback(lambda node: download_to_data(node))
 615         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123\x00a"))
 616
 617         # test APPEND flag, and also replacing an existing file ("newfile")
 618         d.addCallback(lambda ign:
 619                       self.handler.openFile("newfile", sftp.FXF_WRITE | sftp.FXF_CREAT |
 620                                                        sftp.FXF_TRUNC | sftp.FXF_APPEND, {}))
 621         def _write_append(wf):
 622             d2 = wf.writeChunk(0, "0123456789")
 623             d2.addCallback(lambda ign: wf.writeChunk(8, "0123"))
 624             d2.addCallback(lambda ign: wf.close())
 625             return d2
 626         d.addCallback(_write_append)
 627         d.addCallback(lambda ign: self.root.get(u"newfile"))
 628         d.addCallback(lambda node: download_to_data(node))
 629         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "01234567890123"))
 630
 631         # test EXCL flag
 632         d.addCallback(lambda ign:
 633                       self.handler.openFile("excl", sftp.FXF_WRITE | sftp.FXF_CREAT |
 634                                                     sftp.FXF_TRUNC | sftp.FXF_EXCL, {}))
 635         def _write_excl(wf):
 636             d2 = self.root.get(u"excl")
 637             d2.addCallback(lambda node: download_to_data(node))
 638             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
 639
 640             d2.addCallback(lambda ign: wf.writeChunk(0, "0123456789"))
 641             d2.addCallback(lambda ign: wf.close())
 642             return d2
 643         d.addCallback(_write_excl)
 644         d.addCallback(lambda ign: self.root.get(u"excl"))
 645         d.addCallback(lambda node: download_to_data(node))
 646         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 647
 648         # test that writing a zero-length file with EXCL only updates the directory once
 649         d.addCallback(lambda ign:
 650                       self.handler.openFile("zerolength", sftp.FXF_WRITE | sftp.FXF_CREAT |
 651                                                           sftp.FXF_EXCL, {}))
 652         def _write_excl_zerolength(wf):
 653             d2 = self.root.get(u"zerolength")
 654             d2.addCallback(lambda node: download_to_data(node))
 655             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
 656
 657             # FIXME: no API to get the best version number exists (fix as part of #993)
 658             #stash = {}
 659             #d2.addCallback(lambda ign: self.root.get_best_version_number())
 660             #d2.addCallback(lambda version: stash['version'] = version)
 661             d2.addCallback(lambda ign: wf.close())
 662             #d2.addCallback(lambda ign: self.root.get_best_version_number())
 663             #d2.addCallback(lambda new_version: self.failUnlessReallyEqual(new_version, stash['version'])
 664             return d2
 665         d.addCallback(_write_excl_zerolength)
 666         d.addCallback(lambda ign: self.root.get(u"zerolength"))
 667         d.addCallback(lambda node: download_to_data(node))
 668         d.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
 669
 670         # test WRITE | CREAT | EXCL | APPEND
 671         d.addCallback(lambda ign:
 672                       self.handler.openFile("exclappend", sftp.FXF_WRITE | sftp.FXF_CREAT |
 673                                                           sftp.FXF_EXCL | sftp.FXF_APPEND, {}))
 674         def _write_excl_append(wf):
 675             d2 = self.root.get(u"exclappend")
 676             d2.addCallback(lambda node: download_to_data(node))
 677             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, ""))
 678
 679             d2.addCallback(lambda ign: wf.writeChunk(10, "0123456789"))
 680             d2.addCallback(lambda ign: wf.writeChunk(5, "01234"))
 681             d2.addCallback(lambda ign: wf.close())
 682             return d2
 683         d.addCallback(_write_excl_append)
 684         d.addCallback(lambda ign: self.root.get(u"exclappend"))
 685         d.addCallback(lambda node: download_to_data(node))
 686         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345678901234"))
 687
 688         # test WRITE | CREAT without TRUNC
 689         d.addCallback(lambda ign:
 690                       self.handler.openFile("newfile2", sftp.FXF_WRITE | sftp.FXF_CREAT, {}))
 691         def _write_notrunc(wf):
 692             d2 =  wf.writeChunk(0, "0123456789")
 693             d2.addCallback(lambda ign: wf.close())
 694             return d2
 695         d.addCallback(_write_notrunc)
 696         d.addCallback(lambda ign: self.root.get(u"newfile2"))
 697         d.addCallback(lambda node: download_to_data(node))
 698         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 699
 700         # test writing to a mutable file
 701         d.addCallback(lambda ign:
 702                       self.handler.openFile("mutable", sftp.FXF_WRITE, {}))
 703         def _write_mutable(wf):
 704             d2 = wf.writeChunk(8, "new!")
 705             d2.addCallback(lambda ign: wf.close())
 706             return d2
 707         d.addCallback(_write_mutable)
 708         d.addCallback(lambda ign: self.root.get(u"mutable"))
 709         def _check_same_file(node):
 710             self.failUnless(node.is_mutable())
 711             self.failUnlessReallyEqual(node.get_uri(), self.mutable_uri)
 712             return node.download_best_version()
 713         d.addCallback(_check_same_file)
 714         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "mutable new! contents"))
 715
 716         # test READ | WRITE without CREAT or TRUNC
 717         d.addCallback(lambda ign:
 718                       self.handler.openFile("small", sftp.FXF_READ | sftp.FXF_WRITE, {}))
 719         def _read_write(rwf):
 720             d2 = rwf.writeChunk(8, "0123")
 721             d2.addCallback(lambda ign: rwf.readChunk(0, 100))
 722             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123"))
 723             d2.addCallback(lambda ign: rwf.close())
 724             return d2
 725         d.addCallback(_read_write)
 726         d.addCallback(lambda ign: self.root.get(u"small"))
 727         d.addCallback(lambda node: download_to_data(node))
 728         d.addCallback(lambda data: self.failUnlessReallyEqual(data, "012345670123"))
 729
 730         return d
 731
 732     def test_removeFile(self):
 733         d = self._set_up("removeFile")
 734         d.addCallback(lambda ign: self._set_up_tree())
 735
 736         d.addCallback(lambda ign:
 737             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
 738                                          self.handler.removeFile, "nofile"))
 739         d.addCallback(lambda ign:
 740             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nofile",
 741                                          self.handler.removeFile, "nofile"))
 742         d.addCallback(lambda ign:
 743             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeFile nodir/file",
 744                                          self.handler.removeFile, "nodir/file"))
 745         d.addCallback(lambda ign:
 746             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removefile ''",
 747                                          self.handler.removeFile, ""))
 748
 749         # removing a directory should fail
 750         d.addCallback(lambda ign:
 751             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeFile tiny_lit_dir",
 752                                          self.handler.removeFile, "tiny_lit_dir"))
 753
 754         # removing a file should succeed
 755         d.addCallback(lambda ign: self.root.get(u"gro\u00DF"))
 756         d.addCallback(lambda ign: self.handler.removeFile(u"gro\u00DF".encode('utf-8')))
 757         d.addCallback(lambda ign:
 758                       self.shouldFail(NoSuchChildError, "removeFile gross", "gro\\xdf",
 759                                       self.root.get, u"gro\u00DF"))
 760
 761         # removing an unknown should succeed
 762         d.addCallback(lambda ign: self.root.get(u"unknown"))
 763         d.addCallback(lambda ign: self.handler.removeFile("unknown"))
 764         d.addCallback(lambda ign:
 765                       self.shouldFail(NoSuchChildError, "removeFile unknown", "unknown",
 766                                       self.root.get, u"unknown"))
 767
 768         # removing a link to an open file should not prevent it from being read
 769         d.addCallback(lambda ign: self.handler.openFile("small", sftp.FXF_READ, {}))
 770         def _remove_and_read_small(rf):
 771             d2= self.handler.removeFile("small")
 772             d2.addCallback(lambda ign:
 773                            self.shouldFail(NoSuchChildError, "removeFile small", "small",
 774                                            self.root.get, u"small"))
 775             d2.addCallback(lambda ign: rf.readChunk(0, 10))
 776             d2.addCallback(lambda data: self.failUnlessReallyEqual(data, "0123456789"))
 777             d2.addCallback(lambda ign: rf.close())
 778             return d2
 779         d.addCallback(_remove_and_read_small)
 780
 781         return d
 782
 783     def test_removeDirectory(self):
 784         d = self._set_up("removeDirectory")
 785         d.addCallback(lambda ign: self._set_up_tree())
 786
 787         d.addCallback(lambda ign:
 788             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir",
 789                                          self.handler.removeDirectory, "nodir"))
 790         d.addCallback(lambda ign:
 791             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory nodir/nodir",
 792                                          self.handler.removeDirectory, "nodir/nodir"))
 793         d.addCallback(lambda ign:
 794             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "removeDirectory ''",
 795                                          self.handler.removeDirectory, ""))
 796
 797         # removing a file should fail
 798         d.addCallback(lambda ign:
 799             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "removeDirectory gross",
 800                                          self.handler.removeDirectory, u"gro\u00DF".encode('utf-8')))
 801
 802         # removing a directory should succeed
 803         d.addCallback(lambda ign: self.root.get(u"tiny_lit_dir"))
 804         d.addCallback(lambda ign: self.handler.removeDirectory("tiny_lit_dir"))
 805         d.addCallback(lambda ign:
 806                       self.shouldFail(NoSuchChildError, "removeDirectory tiny_lit_dir", "tiny_lit_dir",
 807                                       self.root.get, u"tiny_lit_dir"))
 808
 809         # removing an unknown should succeed
 810         d.addCallback(lambda ign: self.root.get(u"unknown"))
 811         d.addCallback(lambda ign: self.handler.removeDirectory("unknown"))
 812         d.addCallback(lambda err:
 813                       self.shouldFail(NoSuchChildError, "removeDirectory unknown", "unknown",
 814                                       self.root.get, u"unknown"))
 815
 816         return d
 817
 818     def test_renameFile(self):
 819         d = self._set_up("renameFile")
 820         d.addCallback(lambda ign: self._set_up_tree())
 821
 822         # renaming a non-existent file should fail
 823         d.addCallback(lambda ign:
 824             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile nofile newfile",
 825                                          self.handler.renameFile, "nofile", "newfile"))
 826         d.addCallback(lambda ign:
 827             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile '' newfile",
 828                                          self.handler.renameFile, "", "newfile"))
 829
 830         # renaming a file to a non-existent path should fail
 831         d.addCallback(lambda ign:
 832             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small nodir/small",
 833                                          self.handler.renameFile, "small", "nodir/small"))
 834
 835         # renaming a file to an invalid UTF-8 name should fail
 836         d.addCallback(lambda ign:
 837             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small invalid",
 838                                          self.handler.renameFile, "small", "\xFF"))
 839
 840         # renaming a file to or from an URI should fail
 841         d.addCallback(lambda ign:
 842             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small from uri",
 843                                          self.handler.renameFile, "uri/"+self.small_uri, "new"))
 844         d.addCallback(lambda ign:
 845             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "renameFile small to uri",
 846                                          self.handler.renameFile, "small", "uri/fake_uri"))
 847
 848         # renaming a file onto an existing file, directory or unknown should fail
 849         d.addCallback(lambda ign:
 850             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small small2",
 851                                          self.handler.renameFile, "small", "small2"))
 852         d.addCallback(lambda ign:
 853             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small tiny_lit_dir",
 854                                          self.handler.renameFile, "small", "tiny_lit_dir"))
 855         d.addCallback(lambda ign:
 856             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "renameFile small unknown",
 857                                          self.handler.renameFile, "small", "unknown"))
 858
 859         # renaming a file to a correct path should succeed
 860         d.addCallback(lambda ign: self.handler.renameFile("small", "new_small"))
 861         d.addCallback(lambda ign: self.root.get(u"new_small"))
 862         d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.small_uri))
 863
 864         # renaming a file into a subdirectory should succeed (also tests Unicode names)
 865         d.addCallback(lambda ign: self.handler.renameFile(u"gro\u00DF".encode('utf-8'),
 866                                                           u"loop/neue_gro\u00DF".encode('utf-8')))
 867         d.addCallback(lambda ign: self.root.get(u"neue_gro\u00DF"))
 868         d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.gross_uri))
 869
 870         # renaming a directory to a correct path should succeed
 871         d.addCallback(lambda ign: self.handler.renameFile("tiny_lit_dir", "new_tiny_lit_dir"))
 872         d.addCallback(lambda ign: self.root.get(u"new_tiny_lit_dir"))
 873         d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.tiny_lit_dir_uri))
 874
 875         # renaming an unknown to a correct path should succeed
 876         d.addCallback(lambda ign: self.handler.renameFile("unknown", "new_unknown"))
 877         d.addCallback(lambda ign: self.root.get(u"new_unknown"))
 878         d.addCallback(lambda node: self.failUnlessReallyEqual(node.get_uri(), self.unknown_uri))
 879
 880         return d
 881
 882     def test_makeDirectory(self):
 883         d = self._set_up("makeDirectory")
 884         d.addCallback(lambda ign: self._set_up_tree())
 885
 886         # making a directory at a correct path should succeed
 887         d.addCallback(lambda ign: self.handler.makeDirectory("newdir", {'ext_foo': 'bar', 'ctime': 42}))
 888
 889         d.addCallback(lambda ign: self.root.get_child_and_metadata(u"newdir"))
 890         def _got( (child, metadata) ):
 891             self.failUnless(IDirectoryNode.providedBy(child))
 892             self.failUnless(child.is_mutable())
 893             # FIXME
 894             #self.failUnless('ctime' in metadata, metadata)
 895             #self.failUnlessReallyEqual(metadata['ctime'], 42)
 896             #self.failUnless('ext_foo' in metadata, metadata)
 897             #self.failUnlessReallyEqual(metadata['ext_foo'], 'bar')
 898             # TODO: child should be empty
 899         d.addCallback(_got)
 900
 901         # making intermediate directories should also succeed
 902         d.addCallback(lambda ign: self.handler.makeDirectory("newparent/newchild", {}))
 903
 904         d.addCallback(lambda ign: self.root.get(u"newparent"))
 905         def _got_newparent(newparent):
 906             self.failUnless(IDirectoryNode.providedBy(newparent))
 907             self.failUnless(newparent.is_mutable())
 908             return newparent.get(u"newchild")
 909         d.addCallback(_got_newparent)
 910
 911         def _got_newchild(newchild):
 912             self.failUnless(IDirectoryNode.providedBy(newchild))
 913             self.failUnless(newchild.is_mutable())
 914         d.addCallback(_got_newchild)
 915
 916         d.addCallback(lambda ign:
 917             self.shouldFailWithSFTPError(sftp.FX_NO_SUCH_FILE, "makeDirectory invalid UTF-8",
 918                                          self.handler.makeDirectory, "\xFF", {}))
 919
 920         # should fail because there is an existing file "small"
 921         d.addCallback(lambda ign:
 922             self.shouldFailWithSFTPError(sftp.FX_PERMISSION_DENIED, "makeDirectory small",
 923                                          self.handler.makeDirectory, "small", {}))
 924         return d
 925
 926     def test_execCommand_and_openShell(self):
 927         class FakeProtocol:
 928             def __init__(self):
 929                 self.output = ""
 930                 self.reason = None
 931             def write(self, data):
 932                 self.output += data
 933                 return defer.succeed(None)
 934             def processEnded(self, reason):
 935                 self.reason = reason
 936                 return defer.succeed(None)
 937
 938         d = self._set_up("execCommand_and_openShell")
 939
 940         d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
 941         def _exec_df(session):
 942             protocol = FakeProtocol()
 943             d2 = session.execCommand(protocol, "df -P -k /")
 944             d2.addCallback(lambda ign: self.failUnlessIn("1024-blocks", protocol.output))
 945             d2.addCallback(lambda ign: self.failUnless(isinstance(protocol.reason.value, ProcessDone)))
 946             d2.addCallback(lambda ign: session.eofReceived())
 947             d2.addCallback(lambda ign: session.closed())
 948             return d2
 949         d.addCallback(_exec_df)
 950
 951         d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
 952         def _exec_error(session):
 953             protocol = FakeProtocol()
 954             d2 = session.execCommand(protocol, "error")
 955             d2.addCallback(lambda ign: self.failUnlessEqual("", protocol.output))
 956             d2.addCallback(lambda ign: self.failUnless(isinstance(protocol.reason.value, ProcessTerminated)))
 957             d2.addCallback(lambda ign: self.failUnlessEqual(protocol.reason.value.exitCode, 1))
 958             d2.addCallback(lambda ign: session.closed())
 959             return d2
 960         d.addCallback(_exec_error)
 961
 962         d.addCallback(lambda ign: conch_interfaces.ISession(self.handler))
 963         def _openShell(session):
 964             protocol = FakeProtocol()
 965             d2 = session.openShell(protocol)
 966             d2.addCallback(lambda ign: self.failUnlessIn("only SFTP", protocol.output))
 967             d2.addCallback(lambda ign: self.failUnless(isinstance(protocol.reason.value, ProcessTerminated)))
 968             d2.addCallback(lambda ign: self.failUnlessEqual(protocol.reason.value.exitCode, 1))
 969             d2.addCallback(lambda ign: session.closed())
 970             return d2
 971         d.addCallback(_exec_error)
 972
 973         return d
 974
 975     def test_extendedRequest(self):
 976         d = self._set_up("extendedRequest")
 977
 978         d.addCallback(lambda ign: self.handler.extendedRequest("statvfs@openssh.com", "/"))
 979         def _check(res):
 980             self.failUnless(isinstance(res, str))
 981             self.failUnlessEqual(len(res), 8*11)
 982         d.addCallback(_check)
 983
 984         d.addCallback(lambda ign:
 985             self.shouldFailWithSFTPError(sftp.FX_OP_UNSUPPORTED, "extendedRequest foo bar",
 986                                          self.handler.extendedRequest, "foo", "bar"))
 987
 988         return d