← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

- improved handling of non-ascii branch names and test
  patch from Joel Rosdahl

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
 
#
 
3
 
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
6
6
# the Free Software Foundation; either version 2 of the License, or
7
7
# (at your option) any later version.
8
 
#
 
8
 
9
9
# This program is distributed in the hope that it will be useful,
10
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
12
# GNU General Public License for more details.
13
 
#
 
13
 
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
# Mr. Smoketoomuch: I'm sorry?
19
 
# Mr. Bounder: You'd better cut down a little then.
20
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
21
 
#                   then!
22
18
 
23
19
"""Black-box tests for bzr.
24
20
 
28
24
"""
29
25
 
30
26
 
31
 
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
32
 
# Note: Please don't add new tests here, it's too big and bulky.  Instead add
33
 
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
34
 
# UI command/aspect that is being tested.
35
 
 
36
 
 
37
27
from cStringIO import StringIO
38
28
import os
39
29
import re
 
30
import shutil
40
31
import sys
41
32
 
42
 
import bzrlib
43
 
from bzrlib import (
44
 
    osutils,
45
 
    )
46
33
from bzrlib.branch import Branch
 
34
from bzrlib.clone import copy_branch
47
35
from bzrlib.errors import BzrCommandError
48
 
from bzrlib.osutils import (
49
 
    has_symlinks,
50
 
    pathjoin,
51
 
    terminal_width,
52
 
    )
53
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
54
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
55
 
from bzrlib.tests.blackbox import ExternalBase
56
 
from bzrlib.workingtree import WorkingTree
 
36
from bzrlib.osutils import has_symlinks
 
37
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
38
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
39
 
 
40
 
 
41
class ExternalBase(TestCaseInTempDir):
 
42
 
 
43
    def runbzr(self, args, retcode=0, backtick=False):
 
44
        if isinstance(args, basestring):
 
45
            args = args.split()
 
46
 
 
47
        if backtick:
 
48
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
49
        else:
 
50
            return self.run_bzr_captured(args, retcode=retcode)
57
51
 
58
52
 
59
53
class TestCommands(ExternalBase):
60
54
 
 
55
    def test_help_commands(self):
 
56
        self.runbzr('--help')
 
57
        self.runbzr('help')
 
58
        self.runbzr('help commands')
 
59
        self.runbzr('help help')
 
60
        self.runbzr('commit -h')
 
61
 
 
62
    def test_init_branch(self):
 
63
        self.runbzr(['init'])
 
64
 
 
65
    def test_whoami(self):
 
66
        # this should always identify something, if only "john@localhost"
 
67
        self.runbzr("whoami")
 
68
        self.runbzr("whoami --email")
 
69
 
 
70
        self.assertEquals(self.runbzr("whoami --email",
 
71
                                      backtick=True).count('@'), 1)
 
72
        
 
73
    def test_whoami_branch(self):
 
74
        """branch specific user identity works."""
 
75
        self.runbzr('init')
 
76
        f = file('.bzr/email', 'wt')
 
77
        f.write('Branch Identity <branch@identi.ty>')
 
78
        f.close()
 
79
        bzr_email = os.environ.get('BZREMAIL')
 
80
        if bzr_email is not None:
 
81
            del os.environ['BZREMAIL']
 
82
        whoami = self.runbzr("whoami",backtick=True)
 
83
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
84
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
85
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
86
        # Verify that the environment variable overrides the value 
 
87
        # in the file
 
88
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
89
        whoami = self.runbzr("whoami",backtick=True)
 
90
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
91
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
92
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
93
        if bzr_email is not None:
 
94
            os.environ['BZREMAIL'] = bzr_email
 
95
 
61
96
    def test_invalid_commands(self):
62
 
        self.runbzr("pants", retcode=3)
63
 
        self.runbzr("--pants off", retcode=3)
64
 
        self.runbzr("diff --message foo", retcode=3)
 
97
        self.runbzr("pants", retcode=1)
 
98
        self.runbzr("--pants off", retcode=1)
 
99
        self.runbzr("diff --message foo", retcode=1)
 
100
 
 
101
    def test_empty_commit(self):
 
102
        self.runbzr("init")
 
103
        self.build_tree(['hello.txt'])
 
104
        self.runbzr("commit -m empty", retcode=1)
 
105
        self.runbzr("add hello.txt")
 
106
        self.runbzr("commit -m added")
 
107
 
 
108
    def test_empty_commit_message(self):
 
109
        self.runbzr("init")
 
110
        file('foo.c', 'wt').write('int main() {}')
 
111
        self.runbzr(['add', 'foo.c'])
 
112
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
113
 
 
114
    def test_ignore_patterns(self):
 
115
        from bzrlib.branch import Branch
 
116
        
 
117
        b = Branch.initialize('.')
 
118
        self.assertEquals(list(b.unknowns()), [])
 
119
 
 
120
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
121
        self.assertEquals(list(b.unknowns()), [])
 
122
        assert self.capture('unknowns') == ''
 
123
 
 
124
        file('foo.c', 'wt').write('int main() {}')
 
125
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
126
        assert self.capture('unknowns') == 'foo.c\n'
 
127
 
 
128
        self.runbzr(['add', 'foo.c'])
 
129
        assert self.capture('unknowns') == ''
 
130
 
 
131
        # 'ignore' works when creating the .bzignore file
 
132
        file('foo.blah', 'wt').write('blah')
 
133
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
134
        self.runbzr('ignore *.blah')
 
135
        self.assertEquals(list(b.unknowns()), [])
 
136
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
137
 
 
138
        # 'ignore' works when then .bzrignore file already exists
 
139
        file('garh', 'wt').write('garh')
 
140
        self.assertEquals(list(b.unknowns()), ['garh'])
 
141
        assert self.capture('unknowns') == 'garh\n'
 
142
        self.runbzr('ignore garh')
 
143
        self.assertEquals(list(b.unknowns()), [])
 
144
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
65
145
 
66
146
    def test_revert(self):
67
147
        self.runbzr('init')
88
168
        os.rmdir('revertdir')
89
169
        self.runbzr('revert')
90
170
 
91
 
        if has_symlinks():
92
 
            os.symlink('/unlikely/to/exist', 'symlink')
93
 
            self.runbzr('add symlink')
94
 
            self.runbzr('commit -m f')
95
 
            os.unlink('symlink')
96
 
            self.runbzr('revert')
97
 
            self.failUnlessExists('symlink')
98
 
            os.unlink('symlink')
99
 
            os.symlink('a-different-path', 'symlink')
100
 
            self.runbzr('revert')
101
 
            self.assertEqual('/unlikely/to/exist',
102
 
                             os.readlink('symlink'))
103
 
        else:
104
 
            self.log("skipping revert symlink tests")
 
171
        os.symlink('/unlikely/to/exist', 'symlink')
 
172
        self.runbzr('add symlink')
 
173
        self.runbzr('commit -m f')
 
174
        os.unlink('symlink')
 
175
        self.runbzr('revert')
 
176
        self.failUnlessExists('symlink')
 
177
        os.unlink('symlink')
 
178
        os.symlink('a-different-path', 'symlink')
 
179
        self.runbzr('revert')
 
180
        self.assertEqual('/unlikely/to/exist',
 
181
                         os.readlink('symlink'))
105
182
        
106
183
        file('hello', 'wt').write('xyz')
107
184
        self.runbzr('commit -m xyz hello')
113
190
        self.runbzr('revert')
114
191
        os.chdir('..')
115
192
 
 
193
 
 
194
    def test_mv_modes(self):
 
195
        """Test two modes of operation for mv"""
 
196
        from bzrlib.branch import Branch
 
197
        b = Branch.initialize('.')
 
198
        self.build_tree(['a', 'c', 'subdir/'])
 
199
        self.run_bzr_captured(['add', self.test_dir])
 
200
        self.run_bzr_captured(['mv', 'a', 'b'])
 
201
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
202
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
203
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
204
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
205
 
116
206
    def test_main_version(self):
117
207
        """Check output from version command and master option is reasonable"""
118
208
        # output is intentionally passed through to stdout so that we
120
210
        output = self.runbzr('version', backtick=1)
121
211
        self.log('bzr version output:')
122
212
        self.log(output)
123
 
        self.assert_(output.startswith('Bazaar (bzr) '))
 
213
        self.assert_(output.startswith('bzr (bazaar-ng) '))
124
214
        self.assertNotEqual(output.index('Canonical'), -1)
125
215
        # make sure --version is consistent
126
216
        tmp_output = self.runbzr('--version', backtick=1)
137
227
        test.runbzr('add goodbye')
138
228
        test.runbzr('commit -m setup goodbye')
139
229
 
140
 
    def test_pull_verbose(self):
141
 
        """Pull changes from one branch to another and watch the output."""
142
 
 
 
230
    def test_export(self):
 
231
        os.mkdir('branch')
 
232
        os.chdir('branch')
 
233
        self.example_branch()
 
234
        self.runbzr('export ../latest')
 
235
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
236
        self.runbzr('export ../first -r 1')
 
237
        assert not os.path.exists('../first/goodbye')
 
238
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
239
        self.runbzr('export ../first.gz -r 1')
 
240
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
241
        self.runbzr('export ../first.bz2 -r 1')
 
242
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
243
        self.runbzr('export ../first.tar -r 1')
 
244
        assert os.path.isfile('../first.tar')
 
245
        from tarfile import TarFile
 
246
        tf = TarFile('../first.tar')
 
247
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
248
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
249
        self.runbzr('export ../first.tar.gz -r 1')
 
250
        assert os.path.isfile('../first.tar.gz')
 
251
        self.runbzr('export ../first.tbz2 -r 1')
 
252
        assert os.path.isfile('../first.tbz2')
 
253
        self.runbzr('export ../first.tar.bz2 -r 1')
 
254
        assert os.path.isfile('../first.tar.bz2')
 
255
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
256
        assert os.path.isfile('../first.tar.tbz2')
 
257
        from bz2 import BZ2File
 
258
        tf = TarFile('../first.tar.tbz2', 
 
259
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
260
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
261
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
262
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
263
        tf = TarFile('../first2.tar')
 
264
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
265
 
 
266
    def test_diff(self):
 
267
        self.example_branch()
 
268
        file('hello', 'wt').write('hello world!')
 
269
        self.runbzr('commit -m fixing hello')
 
270
        output = self.runbzr('diff -r 2..3', backtick=1)
 
271
        self.assert_('\n+hello world!' in output)
 
272
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
273
        self.assert_('\n+baz' in output)
 
274
 
 
275
    def test_diff_branches(self):
 
276
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
277
        branch = Branch.initialize('branch1')
 
278
        branch.add(['file'])
 
279
        branch.commit('add file')
 
280
        copy_branch(branch, 'branch2')
 
281
        print >> open('branch2/file', 'w'), 'new content'
 
282
        branch2 = Branch.open('branch2')
 
283
        branch2.commit('update file')
 
284
        # should open branch1 and diff against branch2, 
 
285
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
286
        self.assertEquals(("=== modified file 'file'\n"
 
287
                           "--- file\n"
 
288
                           "+++ file\n"
 
289
                           "@@ -1,1 +1,1 @@\n"
 
290
                           "-new content\n"
 
291
                           "+contents of branch1/file\n"
 
292
                           "\n", ''), output)
 
293
 
 
294
    def test_branch(self):
 
295
        """Branch from one branch to another."""
143
296
        os.mkdir('a')
144
297
        os.chdir('a')
145
 
 
146
 
        bzr = self.runbzr
147
298
        self.example_branch()
148
 
 
149
299
        os.chdir('..')
150
 
        bzr('branch a b')
 
300
        self.runbzr('branch a b')
 
301
        self.runbzr('branch a c -r 1')
151
302
        os.chdir('b')
152
 
        open('b', 'wb').write('else\n')
153
 
        bzr('add b')
154
 
        bzr(['commit', '-m', 'added b'])
155
 
 
156
 
        os.chdir('../a')
157
 
        out = bzr('pull --verbose ../b', backtick=True)
158
 
        self.failIfEqual(out.find('Added Revisions:'), -1)
159
 
        self.failIfEqual(out.find('message:\n  added b'), -1)
160
 
        self.failIfEqual(out.find('added b'), -1)
161
 
 
162
 
        # Check that --overwrite --verbose prints out the removed entries
163
 
        bzr('commit -m foo --unchanged')
164
 
        os.chdir('../b')
165
 
        bzr('commit -m baz --unchanged')
166
 
        bzr('pull ../a', retcode=3)
167
 
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
168
 
 
169
 
        remove_loc = out.find('Removed Revisions:')
170
 
        self.failIfEqual(remove_loc, -1)
171
 
        added_loc = out.find('Added Revisions:')
172
 
        self.failIfEqual(added_loc, -1)
173
 
 
174
 
        removed_message = out.find('message:\n  baz')
175
 
        self.failIfEqual(removed_message, -1)
176
 
        self.failUnless(remove_loc < removed_message < added_loc)
177
 
 
178
 
        added_message = out.find('message:\n  foo')
179
 
        self.failIfEqual(added_message, -1)
180
 
        self.failUnless(added_loc < added_message)
 
303
        self.runbzr('commit -m foo --unchanged')
 
304
        os.chdir('..')
 
305
        # naughty - abstraction violations RBC 20050928  
 
306
        print "test_branch used to delete the stores, how is this meant to work ?"
 
307
        #shutil.rmtree('a/.bzr/revision-store')
 
308
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
309
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
310
        self.runbzr('branch a d --basis b')
 
311
 
 
312
    def test_merge(self):
 
313
        from bzrlib.branch import Branch
181
314
        
 
315
        os.mkdir('a')
 
316
        os.chdir('a')
 
317
        self.example_branch()
 
318
        os.chdir('..')
 
319
        self.runbzr('branch a b')
 
320
        os.chdir('b')
 
321
        file('goodbye', 'wt').write('quux')
 
322
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
323
 
 
324
        os.chdir('../a')
 
325
        file('hello', 'wt').write('quuux')
 
326
        # We can't merge when there are in-tree changes
 
327
        self.runbzr('merge ../b', retcode=1)
 
328
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
329
        self.runbzr('merge ../b')
 
330
        self.check_file_contents('goodbye', 'quux')
 
331
        # Merging a branch pulls its revision into the tree
 
332
        a = Branch.open('.')
 
333
        b = Branch.open('../b')
 
334
        a.get_revision_xml(b.last_revision())
 
335
        self.log('pending merges: %s', a.pending_merges())
 
336
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
337
        #        % (a.pending_merges(), b.last_patch())
 
338
 
 
339
    def test_merge_with_missing_file(self):
 
340
        """Merge handles missing file conflicts"""
 
341
        os.mkdir('a')
 
342
        os.chdir('a')
 
343
        os.mkdir('sub')
 
344
        print >> file('sub/a.txt', 'wb'), "hello"
 
345
        print >> file('b.txt', 'wb'), "hello"
 
346
        print >> file('sub/c.txt', 'wb'), "hello"
 
347
        self.runbzr('init')
 
348
        self.runbzr('add')
 
349
        self.runbzr(('commit', '-m', 'added a'))
 
350
        self.runbzr('branch . ../b')
 
351
        print >> file('sub/a.txt', 'ab'), "there"
 
352
        print >> file('b.txt', 'ab'), "there"
 
353
        print >> file('sub/c.txt', 'ab'), "there"
 
354
        self.runbzr(('commit', '-m', 'Added there'))
 
355
        os.unlink('sub/a.txt')
 
356
        os.unlink('sub/c.txt')
 
357
        os.rmdir('sub')
 
358
        os.unlink('b.txt')
 
359
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
360
        os.chdir('../b')
 
361
        print >> file('sub/a.txt', 'ab'), "something"
 
362
        print >> file('b.txt', 'ab'), "something"
 
363
        print >> file('sub/c.txt', 'ab'), "something"
 
364
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
365
        self.runbzr('merge ../a/')
 
366
        assert os.path.exists('sub/a.txt.THIS')
 
367
        assert os.path.exists('sub/a.txt.BASE')
 
368
        os.chdir('../a')
 
369
        self.runbzr('merge ../b/')
 
370
        assert os.path.exists('sub/a.txt.OTHER')
 
371
        assert os.path.exists('sub/a.txt.BASE')
 
372
 
 
373
    def test_pull(self):
 
374
        """Pull changes from one branch to another."""
 
375
        os.mkdir('a')
 
376
        os.chdir('a')
 
377
 
 
378
        self.example_branch()
 
379
        self.runbzr('pull', retcode=1)
 
380
        self.runbzr('missing', retcode=1)
 
381
        self.runbzr('missing .')
 
382
        self.runbzr('missing')
 
383
        self.runbzr('pull')
 
384
        self.runbzr('pull /', retcode=1)
 
385
        self.runbzr('pull')
 
386
 
 
387
        os.chdir('..')
 
388
        self.runbzr('branch a b')
 
389
        os.chdir('b')
 
390
        self.runbzr('pull')
 
391
        os.mkdir('subdir')
 
392
        self.runbzr('add subdir')
 
393
        self.runbzr('commit -m blah --unchanged')
 
394
        os.chdir('../a')
 
395
        a = Branch.open('.')
 
396
        b = Branch.open('../b')
 
397
        assert a.revision_history() == b.revision_history()[:-1]
 
398
        self.runbzr('pull ../b')
 
399
        assert a.revision_history() == b.revision_history()
 
400
        self.runbzr('commit -m blah2 --unchanged')
 
401
        os.chdir('../b')
 
402
        self.runbzr('commit -m blah3 --unchanged')
 
403
        self.runbzr('pull ../a', retcode=1)
 
404
        os.chdir('../a')
 
405
        self.runbzr('merge ../b')
 
406
        self.runbzr('commit -m blah4 --unchanged')
 
407
        os.chdir('../b/subdir')
 
408
        self.runbzr('pull ../../a')
 
409
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
410
        self.runbzr('commit -m blah5 --unchanged')
 
411
        self.runbzr('commit -m blah6 --unchanged')
 
412
        os.chdir('..')
 
413
        self.runbzr('pull ../a')
 
414
        os.chdir('../a')
 
415
        self.runbzr('commit -m blah7 --unchanged')
 
416
        self.runbzr('merge ../b')
 
417
        self.runbzr('commit -m blah8 --unchanged')
 
418
        self.runbzr('pull ../b')
 
419
        self.runbzr('pull ../b')
 
420
 
182
421
    def test_locations(self):
183
422
        """Using and remembering different locations"""
184
423
        os.mkdir('a')
185
424
        os.chdir('a')
186
425
        self.runbzr('init')
187
426
        self.runbzr('commit -m unchanged --unchanged')
188
 
        self.runbzr('pull', retcode=3)
189
 
        self.runbzr('merge', retcode=3)
 
427
        self.runbzr('pull', retcode=1)
 
428
        self.runbzr('merge', retcode=1)
190
429
        self.runbzr('branch . ../b')
191
430
        os.chdir('../b')
192
431
        self.runbzr('pull')
198
437
        self.runbzr('pull')
199
438
        self.runbzr('pull ../c')
200
439
        self.runbzr('branch ../c ../d')
201
 
        osutils.rmtree('../c')
 
440
        shutil.rmtree('../c')
202
441
        self.runbzr('pull')
203
442
        os.chdir('../b')
204
443
        self.runbzr('pull')
205
444
        os.chdir('../d')
206
 
        self.runbzr('pull', retcode=3)
 
445
        self.runbzr('pull', retcode=1)
207
446
        self.runbzr('pull ../a --remember')
208
447
        self.runbzr('pull')
209
448
        
 
449
    def test_add_reports(self):
 
450
        """add command prints the names of added files."""
 
451
        b = Branch.initialize('.')
 
452
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
453
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
454
        # the ordering is not defined at the moment
 
455
        results = sorted(out.rstrip('\n').split('\n'))
 
456
        self.assertEquals(['added dir',
 
457
                           'added dir'+os.sep+'sub.txt',
 
458
                           'added top.txt',],
 
459
                          results)
 
460
 
 
461
    def test_add_quiet_is(self):
 
462
        """add -q does not print the names of added files."""
 
463
        b = Branch.initialize('.')
 
464
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
465
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
466
        # the ordering is not defined at the moment
 
467
        results = sorted(out.rstrip('\n').split('\n'))
 
468
        self.assertEquals([''], results)
 
469
 
210
470
    def test_unknown_command(self):
211
471
        """Handling of unknown command."""
212
472
        out, err = self.run_bzr_captured(['fluffy-badger'],
213
 
                                         retcode=3)
 
473
                                         retcode=1)
214
474
        self.assertEquals(out, '')
215
475
        err.index('unknown command')
216
476
 
217
 
    def create_conflicts(self):
218
 
        """Create a conflicted tree"""
 
477
    def test_conflicts(self):
 
478
        """Handling of merge conflicts"""
219
479
        os.mkdir('base')
220
480
        os.chdir('base')
221
481
        file('hello', 'wb').write("hi world")
235
495
        file('question', 'wb').write("What do you get when you multiply six"
236
496
                                   "times nine?")
237
497
        self.runbzr('commit -m this')
238
 
 
239
 
    def test_status(self):
240
 
        os.mkdir('branch1')
241
 
        os.chdir('branch1')
242
 
        self.runbzr('init')
243
 
        self.runbzr('commit --unchanged --message f')
244
 
        self.runbzr('branch . ../branch2')
245
 
        self.runbzr('branch . ../branch3')
246
 
        self.runbzr('commit --unchanged --message peter')
247
 
        os.chdir('../branch2')
248
 
        self.runbzr('merge ../branch1')
249
 
        self.runbzr('commit --unchanged --message pumpkin')
250
 
        os.chdir('../branch3')
251
 
        self.runbzr('merge ../branch2')
252
 
        message = self.capture('status')
253
 
 
254
 
 
255
 
    def test_conflicts(self):
256
 
        """Handling of merge conflicts"""
257
 
        self.create_conflicts()
258
 
        self.runbzr('merge ../other --show-base', retcode=1)
259
 
        conflict_text = file('hello').read()
260
 
        self.assert_('<<<<<<<' in conflict_text)
261
 
        self.assert_('>>>>>>>' in conflict_text)
262
 
        self.assert_('=======' in conflict_text)
263
 
        self.assert_('|||||||' in conflict_text)
264
 
        self.assert_('hi world' in conflict_text)
265
 
        self.runbzr('revert')
266
 
        self.runbzr('resolve --all')
267
 
        self.runbzr('merge ../other', retcode=1)
268
 
        conflict_text = file('hello').read()
269
 
        self.assert_('|||||||' not in conflict_text)
270
 
        self.assert_('hi world' not in conflict_text)
 
498
        self.runbzr('merge ../other')
271
499
        result = self.runbzr('conflicts', backtick=1)
272
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
273
 
                                  " question\n")
 
500
        self.assertEquals(result, "hello\nquestion\n")
274
501
        result = self.runbzr('status', backtick=1)
275
 
        self.assert_("conflicts:\n  Text conflict in hello\n"
276
 
                     "  Text conflict in question\n" in result, result)
 
502
        assert "conflicts:\n  hello\n  question\n" in result, result
277
503
        self.runbzr('resolve hello')
278
504
        result = self.runbzr('conflicts', backtick=1)
279
 
        self.assertEquals(result, "Text conflict in question\n")
280
 
        self.runbzr('commit -m conflicts', retcode=3)
 
505
        self.assertEquals(result, "question\n")
 
506
        self.runbzr('commit -m conflicts', retcode=1)
281
507
        self.runbzr('resolve --all')
282
508
        result = self.runbzr('conflicts', backtick=1)
283
509
        self.runbzr('commit -m conflicts')
284
510
        self.assertEquals(result, "")
285
511
 
286
 
    def test_push(self):
287
 
        # create a source branch
288
 
        os.mkdir('my-branch')
289
 
        os.chdir('my-branch')
290
 
        self.example_branch()
291
 
 
292
 
        # with no push target, fail
293
 
        self.runbzr('push', retcode=3)
294
 
        # with an explicit target work
295
 
        self.runbzr('push ../output-branch')
296
 
        # with an implicit target work
297
 
        self.runbzr('push')
298
 
        # nothing missing
299
 
        self.runbzr('missing ../output-branch')
300
 
        # advance this branch
301
 
        self.runbzr('commit --unchanged -m unchanged')
302
 
 
303
 
        os.chdir('../output-branch')
304
 
        # There is no longer a difference as long as we have
305
 
        # access to the working tree
306
 
        self.runbzr('diff')
307
 
 
308
 
        # But we should be missing a revision
309
 
        self.runbzr('missing ../my-branch', retcode=1)
310
 
 
311
 
        # diverge the branches
312
 
        self.runbzr('commit --unchanged -m unchanged')
313
 
        os.chdir('../my-branch')
314
 
        # cannot push now
315
 
        self.runbzr('push', retcode=3)
316
 
        # and there are difference
317
 
        self.runbzr('missing ../output-branch', retcode=1)
318
 
        self.runbzr('missing --verbose ../output-branch', retcode=1)
319
 
        # but we can force a push
320
 
        self.runbzr('push --overwrite')
321
 
        # nothing missing
322
 
        self.runbzr('missing ../output-branch')
323
 
        
324
 
        # pushing to a new dir with no parent should fail
325
 
        self.runbzr('push ../missing/new-branch', retcode=3)
326
 
        # unless we provide --create-prefix
327
 
        self.runbzr('push --create-prefix ../missing/new-branch')
328
 
        # nothing missing
329
 
        self.runbzr('missing ../missing/new-branch')
330
 
 
331
 
    def test_external_command(self):
332
 
        """Test that external commands can be run by setting the path
333
 
        """
334
 
        # We don't at present run bzr in a subprocess for blackbox tests, and so 
335
 
        # don't really capture stdout, only the internal python stream.
336
 
        # Therefore we don't use a subcommand that produces any output or does
337
 
        # anything -- we just check that it can be run successfully.  
338
 
        cmd_name = 'test-command'
339
 
        if sys.platform == 'win32':
340
 
            cmd_name += '.bat'
341
 
        oldpath = os.environ.get('BZRPATH', None)
342
 
        bzr = self.capture
343
 
        try:
344
 
            if 'BZRPATH' in os.environ:
345
 
                del os.environ['BZRPATH']
346
 
 
347
 
            f = file(cmd_name, 'wb')
348
 
            if sys.platform == 'win32':
349
 
                f.write('@echo off\n')
350
 
            else:
351
 
                f.write('#!/bin/sh\n')
352
 
            # f.write('echo Hello from test-command')
353
 
            f.close()
354
 
            os.chmod(cmd_name, 0755)
355
 
 
356
 
            # It should not find the command in the local 
357
 
            # directory by default, since it is not in my path
358
 
            bzr(cmd_name, retcode=3)
359
 
 
360
 
            # Now put it into my path
361
 
            os.environ['BZRPATH'] = '.'
362
 
 
363
 
            bzr(cmd_name)
364
 
 
365
 
            # Make sure empty path elements are ignored
366
 
            os.environ['BZRPATH'] = os.pathsep
367
 
 
368
 
            bzr(cmd_name, retcode=3)
369
 
 
370
 
        finally:
371
 
            if oldpath:
372
 
                os.environ['BZRPATH'] = oldpath
373
 
 
374
 
 
375
512
def listdir_sorted(dir):
376
513
    L = os.listdir(dir)
377
514
    L.sort()
395
532
        runbzr('init')
396
533
 
397
534
        self.assertEquals(capture('root').rstrip(),
398
 
                          pathjoin(self.test_dir, 'branch1'))
 
535
                          os.path.join(self.test_dir, 'branch1'))
399
536
 
400
537
        progress("status of new file")
401
538
 
406
543
        self.assertEquals(capture('unknowns'), 'test.txt\n')
407
544
 
408
545
        out = capture("status")
409
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
546
        assert out == 'unknown:\n  test.txt\n'
 
547
 
 
548
        out = capture("status --all")
 
549
        assert out == "unknown:\n  test.txt\n"
 
550
 
 
551
        out = capture("status test.txt --all")
 
552
        assert out == "unknown:\n  test.txt\n"
410
553
 
411
554
        f = file('test2.txt', 'wt')
412
555
        f.write('goodbye cruel world...\n')
413
556
        f.close()
414
557
 
415
558
        out = capture("status test.txt")
416
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
559
        assert out == "unknown:\n  test.txt\n"
417
560
 
418
561
        out = capture("status")
419
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
562
        assert out == ("unknown:\n"
 
563
                       "  test.txt\n"
 
564
                       "  test2.txt\n")
420
565
 
421
566
        os.unlink('test2.txt')
422
567
 
423
568
        progress("command aliases")
424
 
        out = capture("st")
425
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
569
        out = capture("st --all")
 
570
        assert out == ("unknown:\n"
 
571
                       "  test.txt\n")
426
572
 
427
573
        out = capture("stat")
428
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
574
        assert out == ("unknown:\n"
 
575
                       "  test.txt\n")
429
576
 
430
577
        progress("command help")
431
578
        runbzr("help st")
432
579
        runbzr("help")
433
580
        runbzr("help commands")
434
 
        runbzr("help slartibartfast", 3)
 
581
        runbzr("help slartibartfast", 1)
435
582
 
436
583
        out = capture("help ci")
437
584
        out.index('aliases: ')
438
585
 
 
586
        progress("can't rename unversioned file")
 
587
        runbzr("rename test.txt new-test.txt", 1)
 
588
 
 
589
        progress("adding a file")
 
590
 
 
591
        runbzr("add test.txt")
 
592
        assert capture("unknowns") == ''
 
593
        assert capture("status --all") == ("added:\n"
 
594
                                                "  test.txt\n")
 
595
 
 
596
        progress("rename newly-added file")
 
597
        runbzr("rename test.txt hello.txt")
 
598
        assert os.path.exists("hello.txt")
 
599
        assert not os.path.exists("test.txt")
 
600
 
 
601
        assert capture("revno") == '0\n'
 
602
 
 
603
        progress("add first revision")
 
604
        runbzr(['commit', '-m', 'add first revision'])
 
605
 
 
606
        progress("more complex renames")
 
607
        os.mkdir("sub1")
 
608
        runbzr("rename hello.txt sub1", 1)
 
609
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
610
        runbzr("move hello.txt sub1", 1)
 
611
 
 
612
        runbzr("add sub1")
 
613
        runbzr("rename sub1 sub2")
 
614
        runbzr("move hello.txt sub2")
 
615
        self.assertEqual(capture("relpath sub2/hello.txt"),
 
616
                         os.path.join("sub2", "hello.txt\n"))
 
617
 
 
618
        assert exists("sub2")
 
619
        assert exists("sub2/hello.txt")
 
620
        assert not exists("sub1")
 
621
        assert not exists("hello.txt")
 
622
 
 
623
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
624
 
 
625
        mkdir("sub1")
 
626
        runbzr('add sub1')
 
627
        runbzr('move sub2/hello.txt sub1')
 
628
        assert not exists('sub2/hello.txt')
 
629
        assert exists('sub1/hello.txt')
 
630
        runbzr('move sub2 sub1')
 
631
        assert not exists('sub2')
 
632
        assert exists('sub1/sub2')
 
633
 
 
634
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
635
 
 
636
        chdir('sub1/sub2')
 
637
        self.assertEquals(capture('root')[:-1],
 
638
                          os.path.join(self.test_dir, 'branch1'))
 
639
        runbzr('move ../hello.txt .')
 
640
        assert exists('./hello.txt')
 
641
        self.assertEquals(capture('relpath hello.txt'),
 
642
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
643
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
644
        runbzr(['commit', '-m', 'move to parent directory'])
 
645
        chdir('..')
 
646
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
647
 
 
648
        runbzr('move sub2/hello.txt .')
 
649
        assert exists('hello.txt')
 
650
 
439
651
        f = file('hello.txt', 'wt')
440
652
        f.write('some nice new content\n')
441
653
        f.close()
442
654
 
443
 
        runbzr("add hello.txt")
444
 
        
445
655
        f = file('msg.tmp', 'wt')
446
656
        f.write('this is my new commit\nand it has multiple lines, for fun')
447
657
        f.close()
448
658
 
449
659
        runbzr('commit -F msg.tmp')
450
660
 
451
 
        self.assertEquals(capture('revno'), '1\n')
452
 
        runbzr('export -r 1 export-1.tmp')
 
661
        assert capture('revno') == '5\n'
 
662
        runbzr('export -r 5 export-5.tmp')
453
663
        runbzr('export export.tmp')
454
664
 
455
665
        runbzr('log')
456
666
        runbzr('log -v')
457
667
        runbzr('log -v --forward')
458
 
        runbzr('log -m', retcode=3)
 
668
        runbzr('log -m', retcode=1)
459
669
        log_out = capture('log -m commit')
460
 
        self.assert_("this is my new commit\n  and" in log_out)
461
 
        self.assert_("rename nested" not in log_out)
462
 
        self.assert_('revision-id' not in log_out)
463
 
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
670
        assert "this is my new commit\n  and" in log_out
 
671
        assert "rename nested" not in log_out
 
672
        assert 'revision-id' not in log_out
 
673
        assert 'revision-id' in capture('log --show-ids -m commit')
464
674
 
465
675
        log_out = capture('log --line')
466
 
        # determine the widest line we want
467
 
        max_width = terminal_width() - 1
468
676
        for line in log_out.splitlines():
469
 
            self.assert_(len(line) <= max_width, len(line))
470
 
        self.assert_("this is my new commit and" not in log_out)
471
 
        self.assert_("this is my new commit" in log_out)
 
677
            assert len(line) <= 79, len(line)
 
678
        assert "this is my new commit and" in log_out
 
679
 
472
680
 
473
681
        progress("file with spaces in name")
474
682
        mkdir('sub directory')
475
683
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
476
684
        runbzr('add .')
477
 
        runbzr('diff', retcode=1)
 
685
        runbzr('diff')
478
686
        runbzr('commit -m add-spaces')
479
687
        runbzr('check')
480
688
 
490
698
            runbzr('init')
491
699
            os.symlink("NOWHERE1", "link1")
492
700
            runbzr('add link1')
493
 
            self.assertEquals(self.capture('unknowns'), '')
 
701
            assert self.capture('unknowns') == ''
494
702
            runbzr(['commit', '-m', '1: added symlink link1'])
495
703
    
496
704
            mkdir('d1')
497
705
            runbzr('add d1')
498
 
            self.assertEquals(self.capture('unknowns'), '')
 
706
            assert self.capture('unknowns') == ''
499
707
            os.symlink("NOWHERE2", "d1/link2")
500
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
 
708
            assert self.capture('unknowns') == 'd1/link2\n'
501
709
            # is d1/link2 found when adding d1
502
710
            runbzr('add d1')
503
 
            self.assertEquals(self.capture('unknowns'), '')
 
711
            assert self.capture('unknowns') == ''
504
712
            os.symlink("NOWHERE3", "d1/link3")
505
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
713
            assert self.capture('unknowns') == 'd1/link3\n'
506
714
            runbzr(['commit', '-m', '2: added dir, symlink'])
507
715
    
508
716
            runbzr('rename d1 d2')
509
717
            runbzr('move d2/link2 .')
510
718
            runbzr('move link1 d2')
511
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
512
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
719
            assert os.readlink("./link2") == "NOWHERE2"
 
720
            assert os.readlink("d2/link1") == "NOWHERE1"
513
721
            runbzr('add d2/link3')
514
 
            runbzr('diff', retcode=1)
 
722
            runbzr('diff')
515
723
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
516
724
    
517
725
            os.unlink("link2")
518
726
            os.symlink("TARGET 2", "link2")
519
727
            os.unlink("d2/link1")
520
728
            os.symlink("TARGET 1", "d2/link1")
521
 
            runbzr('diff', retcode=1)
522
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
729
            runbzr('diff')
 
730
            assert self.capture("relpath d2/link1") == "d2/link1\n"
523
731
            runbzr(['commit', '-m', '4: retarget of two links'])
524
732
    
525
733
            runbzr('remove d2/link1')
526
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
734
            assert self.capture('unknowns') == 'd2/link1\n'
527
735
            runbzr(['commit', '-m', '5: remove d2/link1'])
528
736
            # try with the rm alias
529
737
            runbzr('add d2/link1')
530
738
            runbzr(['commit', '-m', '6: add d2/link1'])
531
739
            runbzr('rm d2/link1')
532
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
740
            assert self.capture('unknowns') == 'd2/link1\n'
533
741
            runbzr(['commit', '-m', '7: remove d2/link1'])
534
742
    
535
743
            os.mkdir("d1")
536
744
            runbzr('add d1')
537
745
            runbzr('rename d2/link3 d1/link3new')
538
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
746
            assert self.capture('unknowns') == 'd2/link1\n'
539
747
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
540
748
            
541
749
            runbzr(['check'])
542
750
            
543
751
            runbzr(['export', '-r', '1', 'exp1.tmp'])
544
752
            chdir("exp1.tmp")
545
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
546
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
753
            assert listdir_sorted(".") == [ "link1" ]
 
754
            assert os.readlink("link1") == "NOWHERE1"
547
755
            chdir("..")
548
756
            
549
757
            runbzr(['export', '-r', '2', 'exp2.tmp'])
550
758
            chdir("exp2.tmp")
551
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
759
            assert listdir_sorted(".") == [ "d1", "link1" ]
552
760
            chdir("..")
553
761
            
554
762
            runbzr(['export', '-r', '3', 'exp3.tmp'])
555
763
            chdir("exp3.tmp")
556
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
557
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
558
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
559
 
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
 
764
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
765
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
766
            assert os.readlink("d2/link1") == "NOWHERE1"
 
767
            assert os.readlink("link2")    == "NOWHERE2"
560
768
            chdir("..")
561
769
            
562
770
            runbzr(['export', '-r', '4', 'exp4.tmp'])
563
771
            chdir("exp4.tmp")
564
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
565
 
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
566
 
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
567
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
772
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
773
            assert os.readlink("d2/link1") == "TARGET 1"
 
774
            assert os.readlink("link2")    == "TARGET 2"
 
775
            assert listdir_sorted("d2") == [ "link1", "link3" ]
568
776
            chdir("..")
569
777
            
570
778
            runbzr(['export', '-r', '5', 'exp5.tmp'])
571
779
            chdir("exp5.tmp")
572
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
573
 
            self.assert_(os.path.islink("link2"))
574
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
780
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
781
            assert os.path.islink("link2")
 
782
            assert listdir_sorted("d2")== [ "link3" ]
575
783
            chdir("..")
576
784
            
577
785
            runbzr(['export', '-r', '8', 'exp6.tmp'])
578
786
            chdir("exp6.tmp")
579
787
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
580
 
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
581
 
            self.assertEquals(listdir_sorted("d2"), [])
582
 
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
 
788
            assert listdir_sorted("d1") == [ "link3new" ]
 
789
            assert listdir_sorted("d2") == []
 
790
            assert os.readlink("d1/link3new") == "NOWHERE3"
583
791
            chdir("..")
584
792
        else:
585
793
            progress("skipping symlink tests")
586
794
 
587
795
 
588
 
class RemoteTests(object):
 
796
class HttpTests(TestCaseWithWebserver):
589
797
    """Test bzr ui commands against remote branches."""
590
798
 
591
799
    def test_branch(self):
592
800
        os.mkdir('from')
593
 
        wt = self.make_branch_and_tree('from')
594
 
        branch = wt.branch
595
 
        wt.commit('empty commit for nonsense', allow_pointless=True)
596
 
        url = self.get_readonly_url('from')
 
801
        branch = Branch.initialize('from')
 
802
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
803
        url = self.get_remote_url('from')
597
804
        self.run_bzr('branch', url, 'to')
598
805
        branch = Branch.open('to')
599
806
        self.assertEqual(1, len(branch.revision_history()))
600
 
        # the branch should be set in to to from
601
 
        self.assertEqual(url + '/', branch.get_parent())
602
 
 
603
 
    def test_log(self):
604
 
        self.build_tree(['branch/', 'branch/file'])
605
 
        self.capture('init branch')
606
 
        self.capture('add branch/file')
607
 
        self.capture('commit -m foo branch')
608
 
        url = self.get_readonly_url('branch/file')
609
 
        output = self.capture('log %s' % url)
610
 
        self.assertEqual(8, len(output.split('\n')))
611
 
        
612
 
    def test_check(self):
613
 
        self.build_tree(['branch/', 'branch/file'])
614
 
        self.capture('init branch')
615
 
        self.capture('add branch/file')
616
 
        self.capture('commit -m foo branch')
617
 
        url = self.get_readonly_url('branch/')
618
 
        self.run_bzr('check', url)
619
 
    
620
 
    def test_push(self):
621
 
        # create a source branch
622
 
        os.mkdir('my-branch')
623
 
        os.chdir('my-branch')
624
 
        self.run_bzr('init')
625
 
        file('hello', 'wt').write('foo')
626
 
        self.run_bzr('add', 'hello')
627
 
        self.run_bzr('commit', '-m', 'setup')
628
 
 
629
 
        # with an explicit target work
630
 
        self.run_bzr('push', self.get_url('output-branch'))
631
 
 
632
 
    
633
 
class HTTPTests(TestCaseWithWebserver, RemoteTests):
634
 
    """Test various commands against a HTTP server."""
635
 
    
636
 
    
637
 
class SFTPTestsAbsolute(TestCaseWithSFTPServer, RemoteTests):
638
 
    """Test various commands against a SFTP server using abs paths."""
639
 
 
640
 
    
641
 
class SFTPTestsAbsoluteSibling(TestCaseWithSFTPServer, RemoteTests):
642
 
    """Test various commands against a SFTP server using abs paths."""
643
 
 
644
 
    def setUp(self):
645
 
        super(SFTPTestsAbsoluteSibling, self).setUp()
646
 
        self._override_home = '/dev/noone/runs/tests/here'
647
 
 
648
 
    
649
 
class SFTPTestsRelative(TestCaseWithSFTPServer, RemoteTests):
650
 
    """Test various commands against a SFTP server using homedir rel paths."""
651
 
 
652
 
    def setUp(self):
653
 
        super(SFTPTestsRelative, self).setUp()
654
 
        self._get_remote_is_absolute = False
 
807
 
 
808