← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testtransport.py

[merge] jelmer

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testtransport.py
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
from cStringIO import StringIO
 
20
 
 
21
from bzrlib.errors import (NoSuchFile, FileExists, TransportNotPossible,
 
22
                           ConnectionError)
 
23
from bzrlib.selftest import TestCase, TestCaseInTempDir
 
24
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
25
from bzrlib.transport import memory, urlescape
 
26
 
 
27
 
 
28
def _append(fn, txt):
 
29
    """Append the given text (file-like object) to the supplied filename."""
 
30
    f = open(fn, 'ab')
 
31
    f.write(txt)
 
32
    f.flush()
 
33
    f.close()
 
34
    del f
 
35
 
 
36
class TestTransport(TestCase):
 
37
    """Test the non transport-concrete class functionality."""
 
38
 
 
39
    def test_urlescape(self):
 
40
        self.assertEqual('%25', urlescape('%'))
 
41
 
 
42
 
 
43
class TestTransportMixIn(object):
 
44
    """Subclass this, and it will provide a series of tests for a Transport.
 
45
    It assumes that the Transport object is connected to the 
 
46
    current working directory.  So that whatever is done 
 
47
    through the transport, should show up in the working 
 
48
    directory, and vice-versa.
 
49
 
 
50
    This also tests to make sure that the functions work with both
 
51
    generators and lists (assuming iter(list) is effectively a generator)
 
52
    """
 
53
    readonly = False
 
54
    def get_transport(self):
 
55
        """Children should override this to return the Transport object.
 
56
        """
 
57
        raise NotImplementedError
 
58
 
 
59
    def test_has(self):
 
60
        t = self.get_transport()
 
61
 
 
62
        files = ['a', 'b', 'e', 'g', '%']
 
63
        self.build_tree(files)
 
64
        self.assertEqual(t.has('a'), True)
 
65
        self.assertEqual(t.has('c'), False)
 
66
        self.assertEqual(t.has(urlescape('%')), True)
 
67
        self.assertEqual(list(t.has_multi(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])),
 
68
                [True, True, False, False, True, False, True, False])
 
69
        self.assertEqual(t.has_any(['a', 'b', 'c']), True)
 
70
        self.assertEqual(t.has_any(['c', 'd', 'f', urlescape('%%')]), False)
 
71
        self.assertEqual(list(t.has_multi(iter(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']))),
 
72
                [True, True, False, False, True, False, True, False])
 
73
        self.assertEqual(t.has_any(['c', 'c', 'c']), False)
 
74
        self.assertEqual(t.has_any(['b', 'b', 'b']), True)
 
75
 
 
76
    def test_get(self):
 
77
        t = self.get_transport()
 
78
 
 
79
        files = ['a', 'b', 'e', 'g']
 
80
        self.build_tree(files)
 
81
        self.assertEqual(t.get('a').read(), open('a').read())
 
82
        content_f = t.get_multi(files)
 
83
        for path,f in zip(files, content_f):
 
84
            self.assertEqual(open(path).read(), f.read())
 
85
 
 
86
        content_f = t.get_multi(iter(files))
 
87
        for path,f in zip(files, content_f):
 
88
            self.assertEqual(open(path).read(), f.read())
 
89
 
 
90
        self.assertRaises(NoSuchFile, t.get, 'c')
 
91
        try:
 
92
            files = list(t.get_multi(['a', 'b', 'c']))
 
93
        except NoSuchFile:
 
94
            pass
 
95
        else:
 
96
            self.fail('Failed to raise NoSuchFile for missing file in get_multi')
 
97
        try:
 
98
            files = list(t.get_multi(iter(['a', 'b', 'c', 'e'])))
 
99
        except NoSuchFile:
 
100
            pass
 
101
        else:
 
102
            self.fail('Failed to raise NoSuchFile for missing file in get_multi')
 
103
 
 
104
    def test_put(self):
 
105
        t = self.get_transport()
 
106
 
 
107
        if self.readonly:
 
108
            self.assertRaises(TransportNotPossible,
 
109
                    t.put, 'a', 'some text for a\n')
 
110
            open('a', 'wb').write('some text for a\n')
 
111
        else:
 
112
            t.put('a', 'some text for a\n')
 
113
        self.assert_(os.path.exists('a'))
 
114
        self.check_file_contents('a', 'some text for a\n')
 
115
        self.assertEqual(t.get('a').read(), 'some text for a\n')
 
116
        # Make sure 'has' is updated
 
117
        self.assertEqual(list(t.has_multi(['a', 'b', 'c', 'd', 'e'])),
 
118
                [True, False, False, False, False])
 
119
        if self.readonly:
 
120
            self.assertRaises(TransportNotPossible,
 
121
                    t.put_multi,
 
122
                    [('a', 'new\ncontents for\na\n'),
 
123
                        ('d', 'contents\nfor d\n')])
 
124
            open('a', 'wb').write('new\ncontents for\na\n')
 
125
            open('d', 'wb').write('contents\nfor d\n')
 
126
        else:
 
127
            # Put also replaces contents
 
128
            self.assertEqual(t.put_multi([('a', 'new\ncontents for\na\n'),
 
129
                                          ('d', 'contents\nfor d\n')]),
 
130
                             2)
 
131
        self.assertEqual(list(t.has_multi(['a', 'b', 'c', 'd', 'e'])),
 
132
                [True, False, False, True, False])
 
133
        self.check_file_contents('a', 'new\ncontents for\na\n')
 
134
        self.check_file_contents('d', 'contents\nfor d\n')
 
135
 
 
136
        if self.readonly:
 
137
            self.assertRaises(TransportNotPossible,
 
138
                t.put_multi, iter([('a', 'diff\ncontents for\na\n'),
 
139
                                  ('d', 'another contents\nfor d\n')]))
 
140
            open('a', 'wb').write('diff\ncontents for\na\n')
 
141
            open('d', 'wb').write('another contents\nfor d\n')
 
142
        else:
 
143
            self.assertEqual(
 
144
                t.put_multi(iter([('a', 'diff\ncontents for\na\n'),
 
145
                                  ('d', 'another contents\nfor d\n')]))
 
146
                             , 2)
 
147
        self.check_file_contents('a', 'diff\ncontents for\na\n')
 
148
        self.check_file_contents('d', 'another contents\nfor d\n')
 
149
 
 
150
        if self.readonly:
 
151
            self.assertRaises(TransportNotPossible,
 
152
                    t.put, 'path/doesnt/exist/c', 'contents')
 
153
        else:
 
154
            self.assertRaises(NoSuchFile,
 
155
                    t.put, 'path/doesnt/exist/c', 'contents')
 
156
 
 
157
    def test_put_file(self):
 
158
        t = self.get_transport()
 
159
 
 
160
        # Test that StringIO can be used as a file-like object with put
 
161
        f1 = StringIO('this is a string\nand some more stuff\n')
 
162
        if self.readonly:
 
163
            open('f1', 'wb').write(f1.read())
 
164
        else:
 
165
            t.put('f1', f1)
 
166
 
 
167
        del f1
 
168
 
 
169
        self.check_file_contents('f1', 
 
170
                'this is a string\nand some more stuff\n')
 
171
 
 
172
        f2 = StringIO('here is some text\nand a bit more\n')
 
173
        f3 = StringIO('some text for the\nthird file created\n')
 
174
 
 
175
        if self.readonly:
 
176
            open('f2', 'wb').write(f2.read())
 
177
            open('f3', 'wb').write(f3.read())
 
178
        else:
 
179
            t.put_multi([('f2', f2), ('f3', f3)])
 
180
 
 
181
        del f2, f3
 
182
 
 
183
        self.check_file_contents('f2', 'here is some text\nand a bit more\n')
 
184
        self.check_file_contents('f3', 'some text for the\nthird file created\n')
 
185
 
 
186
        # Test that an actual file object can be used with put
 
187
        f4 = open('f1', 'rb')
 
188
        if self.readonly:
 
189
            open('f4', 'wb').write(f4.read())
 
190
        else:
 
191
            t.put('f4', f4)
 
192
 
 
193
        del f4
 
194
 
 
195
        self.check_file_contents('f4', 
 
196
                'this is a string\nand some more stuff\n')
 
197
 
 
198
        f5 = open('f2', 'rb')
 
199
        f6 = open('f3', 'rb')
 
200
        if self.readonly:
 
201
            open('f5', 'wb').write(f5.read())
 
202
            open('f6', 'wb').write(f6.read())
 
203
        else:
 
204
            t.put_multi([('f5', f5), ('f6', f6)])
 
205
 
 
206
        del f5, f6
 
207
 
 
208
        self.check_file_contents('f5', 'here is some text\nand a bit more\n')
 
209
        self.check_file_contents('f6', 'some text for the\nthird file created\n')
 
210
 
 
211
 
 
212
 
 
213
    def test_mkdir(self):
 
214
        t = self.get_transport()
 
215
 
 
216
        # Test mkdir
 
217
        os.mkdir('dir_a')
 
218
        self.assertEqual(t.has('dir_a'), True)
 
219
        self.assertEqual(t.has('dir_b'), False)
 
220
 
 
221
        if self.readonly:
 
222
            self.assertRaises(TransportNotPossible,
 
223
                    t.mkdir, 'dir_b')
 
224
            os.mkdir('dir_b')
 
225
        else:
 
226
            t.mkdir('dir_b')
 
227
        self.assertEqual(t.has('dir_b'), True)
 
228
        self.assert_(os.path.isdir('dir_b'))
 
229
 
 
230
        if self.readonly:
 
231
            self.assertRaises(TransportNotPossible,
 
232
                    t.mkdir_multi, ['dir_c', 'dir_d'])
 
233
            os.mkdir('dir_c')
 
234
            os.mkdir('dir_d')
 
235
        else:
 
236
            t.mkdir_multi(['dir_c', 'dir_d'])
 
237
 
 
238
        if self.readonly:
 
239
            self.assertRaises(TransportNotPossible,
 
240
                    t.mkdir_multi, iter(['dir_e', 'dir_f']))
 
241
            os.mkdir('dir_e')
 
242
            os.mkdir('dir_f')
 
243
        else:
 
244
            t.mkdir_multi(iter(['dir_e', 'dir_f']))
 
245
        self.assertEqual(list(t.has_multi(
 
246
            ['dir_a', 'dir_b', 'dir_c', 'dir_q',
 
247
             'dir_d', 'dir_e', 'dir_f', 'dir_b'])),
 
248
            [True, True, True, False,
 
249
             True, True, True, True])
 
250
        for d in ['dir_a', 'dir_b', 'dir_c', 'dir_d', 'dir_e', 'dir_f']:
 
251
            self.assert_(os.path.isdir(d))
 
252
 
 
253
        if not self.readonly:
 
254
            self.assertRaises(NoSuchFile, t.mkdir, 'path/doesnt/exist')
 
255
            self.assertRaises(FileExists, t.mkdir, 'dir_a') # Creating a directory again should fail
 
256
 
 
257
        # Make sure the transport recognizes when a
 
258
        # directory is created by other means
 
259
        # Caching Transports will fail, because dir_e was already seen not
 
260
        # to exist. So instead, we will search for a new directory
 
261
        #os.mkdir('dir_e')
 
262
        #if not self.readonly:
 
263
        #    self.assertRaises(FileExists, t.mkdir, 'dir_e')
 
264
 
 
265
        os.mkdir('dir_g')
 
266
        if not self.readonly:
 
267
            self.assertRaises(FileExists, t.mkdir, 'dir_g')
 
268
 
 
269
        # Test get/put in sub-directories
 
270
        if self.readonly:
 
271
            open('dir_a/a', 'wb').write('contents of dir_a/a')
 
272
            open('dir_b/b', 'wb').write('contents of dir_b/b')
 
273
        else:
 
274
            self.assertEqual(
 
275
                t.put_multi([('dir_a/a', 'contents of dir_a/a'),
 
276
                             ('dir_b/b', 'contents of dir_b/b')])
 
277
                          , 2)
 
278
        for f in ('dir_a/a', 'dir_b/b'):
 
279
            self.assertEqual(t.get(f).read(), open(f).read())
 
280
 
 
281
    def test_copy_to(self):
 
282
        import tempfile
 
283
        from bzrlib.transport.local import LocalTransport
 
284
 
 
285
        t = self.get_transport()
 
286
 
 
287
        files = ['a', 'b', 'c', 'd']
 
288
        self.build_tree(files)
 
289
 
 
290
        dtmp = tempfile.mkdtemp(dir='.', prefix='test-transport-')
 
291
        dtmp_base = os.path.basename(dtmp)
 
292
        local_t = LocalTransport(dtmp)
 
293
 
 
294
        t.copy_to(files, local_t)
 
295
        for f in files:
 
296
            self.assertEquals(open(f).read(),
 
297
                    open(os.path.join(dtmp_base, f)).read())
 
298
 
 
299
        # Test that copying into a missing directory raises
 
300
        # NoSuchFile
 
301
        os.mkdir('e')
 
302
        open('e/f', 'wb').write('contents of e')
 
303
        self.assertRaises(NoSuchFile, t.copy_to, ['e/f'], local_t)
 
304
 
 
305
        os.mkdir(os.path.join(dtmp_base, 'e'))
 
306
        t.copy_to(['e/f'], local_t)
 
307
 
 
308
        del dtmp, dtmp_base, local_t
 
309
 
 
310
        dtmp = tempfile.mkdtemp(dir='.', prefix='test-transport-')
 
311
        dtmp_base = os.path.basename(dtmp)
 
312
        local_t = LocalTransport(dtmp)
 
313
 
 
314
        files = ['a', 'b', 'c', 'd']
 
315
        t.copy_to(iter(files), local_t)
 
316
        for f in files:
 
317
            self.assertEquals(open(f).read(),
 
318
                    open(os.path.join(dtmp_base, f)).read())
 
319
 
 
320
        del dtmp, dtmp_base, local_t
 
321
 
 
322
    def test_append(self):
 
323
        t = self.get_transport()
 
324
 
 
325
        if self.readonly:
 
326
            open('a', 'wb').write('diff\ncontents for\na\n')
 
327
            open('b', 'wb').write('contents\nfor b\n')
 
328
        else:
 
329
            t.put_multi([
 
330
                    ('a', 'diff\ncontents for\na\n'),
 
331
                    ('b', 'contents\nfor b\n')
 
332
                    ])
 
333
 
 
334
        if self.readonly:
 
335
            self.assertRaises(TransportNotPossible,
 
336
                    t.append, 'a', 'add\nsome\nmore\ncontents\n')
 
337
            _append('a', 'add\nsome\nmore\ncontents\n')
 
338
        else:
 
339
            t.append('a', 'add\nsome\nmore\ncontents\n')
 
340
 
 
341
        self.check_file_contents('a', 
 
342
            'diff\ncontents for\na\nadd\nsome\nmore\ncontents\n')
 
343
 
 
344
        if self.readonly:
 
345
            self.assertRaises(TransportNotPossible,
 
346
                    t.append_multi,
 
347
                        [('a', 'and\nthen\nsome\nmore\n'),
 
348
                         ('b', 'some\nmore\nfor\nb\n')])
 
349
            _append('a', 'and\nthen\nsome\nmore\n')
 
350
            _append('b', 'some\nmore\nfor\nb\n')
 
351
        else:
 
352
            t.append_multi([('a', 'and\nthen\nsome\nmore\n'),
 
353
                    ('b', 'some\nmore\nfor\nb\n')])
 
354
        self.check_file_contents('a', 
 
355
            'diff\ncontents for\na\n'
 
356
            'add\nsome\nmore\ncontents\n'
 
357
            'and\nthen\nsome\nmore\n')
 
358
        self.check_file_contents('b', 
 
359
                'contents\nfor b\n'
 
360
                'some\nmore\nfor\nb\n')
 
361
 
 
362
        if self.readonly:
 
363
            _append('a', 'a little bit more\n')
 
364
            _append('b', 'from an iterator\n')
 
365
        else:
 
366
            t.append_multi(iter([('a', 'a little bit more\n'),
 
367
                    ('b', 'from an iterator\n')]))
 
368
        self.check_file_contents('a', 
 
369
            'diff\ncontents for\na\n'
 
370
            'add\nsome\nmore\ncontents\n'
 
371
            'and\nthen\nsome\nmore\n'
 
372
            'a little bit more\n')
 
373
        self.check_file_contents('b', 
 
374
                'contents\nfor b\n'
 
375
                'some\nmore\nfor\nb\n'
 
376
                'from an iterator\n')
 
377
 
 
378
    def test_append_file(self):
 
379
        t = self.get_transport()
 
380
 
 
381
        contents = [
 
382
            ('f1', 'this is a string\nand some more stuff\n'),
 
383
            ('f2', 'here is some text\nand a bit more\n'),
 
384
            ('f3', 'some text for the\nthird file created\n'),
 
385
            ('f4', 'this is a string\nand some more stuff\n'),
 
386
            ('f5', 'here is some text\nand a bit more\n'),
 
387
            ('f6', 'some text for the\nthird file created\n')
 
388
        ]
 
389
        
 
390
        if self.readonly:
 
391
            for f, val in contents:
 
392
                open(f, 'wb').write(val)
 
393
        else:
 
394
            t.put_multi(contents)
 
395
 
 
396
        a1 = StringIO('appending to\none\n')
 
397
        if self.readonly:
 
398
            _append('f1', a1.read())
 
399
        else:
 
400
            t.append('f1', a1)
 
401
 
 
402
        del a1
 
403
 
 
404
        self.check_file_contents('f1', 
 
405
                'this is a string\nand some more stuff\n'
 
406
                'appending to\none\n')
 
407
 
 
408
        a2 = StringIO('adding more\ntext to two\n')
 
409
        a3 = StringIO('some garbage\nto put in three\n')
 
410
 
 
411
        if self.readonly:
 
412
            _append('f2', a2.read())
 
413
            _append('f3', a3.read())
 
414
        else:
 
415
            t.append_multi([('f2', a2), ('f3', a3)])
 
416
 
 
417
        del a2, a3
 
418
 
 
419
        self.check_file_contents('f2',
 
420
                'here is some text\nand a bit more\n'
 
421
                'adding more\ntext to two\n')
 
422
        self.check_file_contents('f3', 
 
423
                'some text for the\nthird file created\n'
 
424
                'some garbage\nto put in three\n')
 
425
 
 
426
        # Test that an actual file object can be used with put
 
427
        a4 = open('f1', 'rb')
 
428
        if self.readonly:
 
429
            _append('f4', a4.read())
 
430
        else:
 
431
            t.append('f4', a4)
 
432
 
 
433
        del a4
 
434
 
 
435
        self.check_file_contents('f4', 
 
436
                'this is a string\nand some more stuff\n'
 
437
                'this is a string\nand some more stuff\n'
 
438
                'appending to\none\n')
 
439
 
 
440
        a5 = open('f2', 'rb')
 
441
        a6 = open('f3', 'rb')
 
442
        if self.readonly:
 
443
            _append('f5', a5.read())
 
444
            _append('f6', a6.read())
 
445
        else:
 
446
            t.append_multi([('f5', a5), ('f6', a6)])
 
447
 
 
448
        del a5, a6
 
449
 
 
450
        self.check_file_contents('f5',
 
451
                'here is some text\nand a bit more\n'
 
452
                'here is some text\nand a bit more\n'
 
453
                'adding more\ntext to two\n')
 
454
        self.check_file_contents('f6',
 
455
                'some text for the\nthird file created\n'
 
456
                'some text for the\nthird file created\n'
 
457
                'some garbage\nto put in three\n')
 
458
 
 
459
    def test_delete(self):
 
460
        # TODO: Test Transport.delete
 
461
        pass
 
462
 
 
463
    def test_move(self):
 
464
        # TODO: Test Transport.move
 
465
        pass
 
466
 
 
467
    def test_connection_error(self):
 
468
        """ConnectionError is raised when connection is impossible"""
 
469
        if not hasattr(self, "get_bogus_transport"):
 
470
            return
 
471
        t = self.get_bogus_transport()
 
472
        self.assertRaises(ConnectionError, t.get, '.bzr/branch')
 
473
 
 
474
        
 
475
class LocalTransportTest(TestCaseInTempDir, TestTransportMixIn):
 
476
    def get_transport(self):
 
477
        from bzrlib.transport.local import LocalTransport
 
478
        return LocalTransport('.')
 
479
 
 
480
 
 
481
class HttpTransportTest(TestCaseWithWebserver, TestTransportMixIn):
 
482
 
 
483
    readonly = True
 
484
 
 
485
    def get_transport(self):
 
486
        from bzrlib.transport.http import HttpTransport
 
487
        url = self.get_remote_url('.')
 
488
        return HttpTransport(url)
 
489
 
 
490
    def get_bogus_transport(self):
 
491
        from bzrlib.transport.http import HttpTransport
 
492
        return HttpTransport('http://jasldkjsalkdjalksjdkljasd')
 
493
 
 
494
 
 
495
class TestMemoryTransport(TestCase):
 
496
 
 
497
    def test_get_transport(self):
 
498
        memory.MemoryTransport()
 
499
 
 
500
    def test_clone(self):
 
501
        transport = memory.MemoryTransport()
 
502
        self.failUnless(transport.clone() is transport)
 
503
 
 
504
    def test_abspath(self):
 
505
        transport = memory.MemoryTransport()
 
506
        self.assertEqual("in-memory:relpath", transport.abspath('relpath'))
 
507
 
 
508
    def test_relpath(self):
 
509
        transport = memory.MemoryTransport()
 
510
 
 
511
    def test_append_and_get(self):
 
512
        transport = memory.MemoryTransport()
 
513
        transport.append('path', StringIO('content'))
 
514
        self.assertEqual(transport.get('path').read(), 'content')
 
515
        transport.append('path', StringIO('content'))
 
516
        self.assertEqual(transport.get('path').read(), 'contentcontent')
 
517
 
 
518
    def test_put_and_get(self):
 
519
        transport = memory.MemoryTransport()
 
520
        transport.put('path', StringIO('content'))
 
521
        self.assertEqual(transport.get('path').read(), 'content')
 
522
        transport.put('path', StringIO('content'))
 
523
        self.assertEqual(transport.get('path').read(), 'content')
 
524
 
 
525
    def test_append_without_dir_fails(self):
 
526
        transport = memory.MemoryTransport()
 
527
        self.assertRaises(NoSuchFile,
 
528
                          transport.append, 'dir/path', StringIO('content'))
 
529
 
 
530
    def test_put_without_dir_fails(self):
 
531
        transport = memory.MemoryTransport()
 
532
        self.assertRaises(NoSuchFile,
 
533
                          transport.put, 'dir/path', StringIO('content'))
 
534
 
 
535
    def test_get_missing(self):
 
536
        transport = memory.MemoryTransport()
 
537
        self.assertRaises(NoSuchFile, transport.get, 'foo')
 
538
 
 
539
    def test_has_missing(self):
 
540
        transport = memory.MemoryTransport()
 
541
        self.assertEquals(False, transport.has('foo'))
 
542
 
 
543
    def test_has_present(self):
 
544
        transport = memory.MemoryTransport()
 
545
        transport.append('foo', StringIO('content'))
 
546
        self.assertEquals(True, transport.has('foo'))
 
547
 
 
548
    def test_mkdir(self):
 
549
        transport = memory.MemoryTransport()
 
550
        transport.mkdir('dir')
 
551
        transport.append('dir/path', StringIO('content'))
 
552
        self.assertEqual(transport.get('dir/path').read(), 'content')
 
553
 
 
554
    def test_mkdir_missing_parent(self):
 
555
        transport = memory.MemoryTransport()
 
556
        self.assertRaises(NoSuchFile,
 
557
                          transport.mkdir, 'dir/dir')
 
558
 
 
559
    def test_mkdir_twice(self):
 
560
        transport = memory.MemoryTransport()
 
561
        transport.mkdir('dir')
 
562
        self.assertRaises(FileExists, transport.mkdir, 'dir')
 
563
 
 
564
    def test_parameters(self):
 
565
        transport = memory.MemoryTransport()
 
566
        self.assertEqual(True, transport.listable())
 
567
        self.assertEqual(False, transport.should_cache())
 
568
 
 
569
    def test_iter_files_recursive(self):
 
570
        transport = memory.MemoryTransport()
 
571
        transport.mkdir('dir')
 
572
        transport.put('dir/foo', StringIO('content'))
 
573
        transport.put('dir/bar', StringIO('content'))
 
574
        transport.put('bar', StringIO('content'))
 
575
        paths = set(transport.iter_files_recursive())
 
576
        self.assertEqual(set(['dir/foo', 'dir/bar', 'bar']), paths)
 
577
 
 
578
    def test_stat(self):
 
579
        transport = memory.MemoryTransport()
 
580
        transport.put('foo', StringIO('content'))
 
581
        transport.put('bar', StringIO('phowar'))
 
582
        self.assertEqual(7, transport.stat('foo').st_size)
 
583
        self.assertEqual(6, transport.stat('bar').st_size)
 
584