← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

- tweak diff shown by assertEqualDiff

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