← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-10-06 22:15:52 UTC
  • mfrom: (1185.13.2)
  • mto: This revision was merged to the branch mainline in revision 1420.
  • Revision ID: robertc@robertcollins.net-20051006221552-9b15c96fa504e0ad
merge from upstream

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
47
34
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
 
35
from bzrlib.osutils import has_symlinks
 
36
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
37
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
38
 
 
39
 
 
40
class ExternalBase(TestCaseInTempDir):
 
41
 
 
42
    def runbzr(self, args, retcode=0, backtick=False):
 
43
        if isinstance(args, basestring):
 
44
            args = args.split()
 
45
 
 
46
        if backtick:
 
47
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
48
        else:
 
49
            return self.run_bzr_captured(args, retcode=retcode)
57
50
 
58
51
 
59
52
class TestCommands(ExternalBase):
60
53
 
 
54
    def test_help_commands(self):
 
55
        self.runbzr('--help')
 
56
        self.runbzr('help')
 
57
        self.runbzr('help commands')
 
58
        self.runbzr('help help')
 
59
        self.runbzr('commit -h')
 
60
 
 
61
    def test_init_branch(self):
 
62
        self.runbzr(['init'])
 
63
 
 
64
    def test_whoami(self):
 
65
        # this should always identify something, if only "john@localhost"
 
66
        self.runbzr("whoami")
 
67
        self.runbzr("whoami --email")
 
68
 
 
69
        self.assertEquals(self.runbzr("whoami --email",
 
70
                                      backtick=True).count('@'), 1)
 
71
        
 
72
    def test_whoami_branch(self):
 
73
        """branch specific user identity works."""
 
74
        self.runbzr('init')
 
75
        f = file('.bzr/email', 'wt')
 
76
        f.write('Branch Identity <branch@identi.ty>')
 
77
        f.close()
 
78
        bzr_email = os.environ.get('BZREMAIL')
 
79
        if bzr_email is not None:
 
80
            del os.environ['BZREMAIL']
 
81
        whoami = self.runbzr("whoami",backtick=True)
 
82
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
83
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
84
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
85
        # Verify that the environment variable overrides the value 
 
86
        # in the file
 
87
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
88
        whoami = self.runbzr("whoami",backtick=True)
 
89
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
90
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
91
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
92
        if bzr_email is not None:
 
93
            os.environ['BZREMAIL'] = bzr_email
 
94
 
61
95
    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)
 
96
        self.runbzr("pants", retcode=1)
 
97
        self.runbzr("--pants off", retcode=1)
 
98
        self.runbzr("diff --message foo", retcode=1)
 
99
 
 
100
    def test_empty_commit(self):
 
101
        self.runbzr("init")
 
102
        self.build_tree(['hello.txt'])
 
103
        self.runbzr("commit -m empty", retcode=1)
 
104
        self.runbzr("add hello.txt")
 
105
        self.runbzr("commit -m added")
 
106
 
 
107
    def test_empty_commit_message(self):
 
108
        self.runbzr("init")
 
109
        file('foo.c', 'wt').write('int main() {}')
 
110
        self.runbzr(['add', 'foo.c'])
 
111
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
112
 
 
113
    def test_ignore_patterns(self):
 
114
        from bzrlib.branch import Branch
 
115
        
 
116
        b = Branch.initialize('.')
 
117
        self.assertEquals(list(b.unknowns()), [])
 
118
 
 
119
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
120
        self.assertEquals(list(b.unknowns()), [])
 
121
        assert self.capture('unknowns') == ''
 
122
 
 
123
        file('foo.c', 'wt').write('int main() {}')
 
124
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
125
        assert self.capture('unknowns') == 'foo.c\n'
 
126
 
 
127
        self.runbzr(['add', 'foo.c'])
 
128
        assert self.capture('unknowns') == ''
 
129
 
 
130
        # 'ignore' works when creating the .bzignore file
 
131
        file('foo.blah', 'wt').write('blah')
 
132
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
133
        self.runbzr('ignore *.blah')
 
134
        self.assertEquals(list(b.unknowns()), [])
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
136
 
 
137
        # 'ignore' works when then .bzrignore file already exists
 
138
        file('garh', 'wt').write('garh')
 
139
        self.assertEquals(list(b.unknowns()), ['garh'])
 
140
        assert self.capture('unknowns') == 'garh\n'
 
141
        self.runbzr('ignore garh')
 
142
        self.assertEquals(list(b.unknowns()), [])
 
143
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
65
144
 
66
145
    def test_revert(self):
67
146
        self.runbzr('init')
88
167
        os.rmdir('revertdir')
89
168
        self.runbzr('revert')
90
169
 
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")
 
170
        os.symlink('/unlikely/to/exist', 'symlink')
 
171
        self.runbzr('add symlink')
 
172
        self.runbzr('commit -m f')
 
173
        os.unlink('symlink')
 
174
        self.runbzr('revert')
105
175
        
106
176
        file('hello', 'wt').write('xyz')
107
177
        self.runbzr('commit -m xyz hello')
113
183
        self.runbzr('revert')
114
184
        os.chdir('..')
115
185
 
 
186
 
 
187
    def test_mv_modes(self):
 
188
        """Test two modes of operation for mv"""
 
189
        from bzrlib.branch import Branch
 
190
        b = Branch.initialize('.')
 
191
        self.build_tree(['a', 'c', 'subdir/'])
 
192
        self.run_bzr_captured(['add', self.test_dir])
 
193
        self.run_bzr_captured(['mv', 'a', 'b'])
 
194
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
195
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
196
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
197
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
198
 
116
199
    def test_main_version(self):
117
200
        """Check output from version command and master option is reasonable"""
118
201
        # output is intentionally passed through to stdout so that we
120
203
        output = self.runbzr('version', backtick=1)
121
204
        self.log('bzr version output:')
122
205
        self.log(output)
123
 
        self.assert_(output.startswith('Bazaar (bzr) '))
 
206
        self.assert_(output.startswith('bzr (bazaar-ng) '))
124
207
        self.assertNotEqual(output.index('Canonical'), -1)
125
208
        # make sure --version is consistent
126
209
        tmp_output = self.runbzr('--version', backtick=1)
137
220
        test.runbzr('add goodbye')
138
221
        test.runbzr('commit -m setup goodbye')
139
222
 
140
 
    def test_pull_verbose(self):
141
 
        """Pull changes from one branch to another and watch the output."""
142
 
 
 
223
    def test_export(self):
 
224
        os.mkdir('branch')
 
225
        os.chdir('branch')
 
226
        self.example_branch()
 
227
        self.runbzr('export ../latest')
 
228
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
229
        self.runbzr('export ../first -r 1')
 
230
        assert not os.path.exists('../first/goodbye')
 
231
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
232
        self.runbzr('export ../first.gz -r 1')
 
233
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
234
        self.runbzr('export ../first.bz2 -r 1')
 
235
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
236
        self.runbzr('export ../first.tar -r 1')
 
237
        assert os.path.isfile('../first.tar')
 
238
        from tarfile import TarFile
 
239
        tf = TarFile('../first.tar')
 
240
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
241
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
242
        self.runbzr('export ../first.tar.gz -r 1')
 
243
        assert os.path.isfile('../first.tar.gz')
 
244
        self.runbzr('export ../first.tbz2 -r 1')
 
245
        assert os.path.isfile('../first.tbz2')
 
246
        self.runbzr('export ../first.tar.bz2 -r 1')
 
247
        assert os.path.isfile('../first.tar.bz2')
 
248
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
249
        assert os.path.isfile('../first.tar.tbz2')
 
250
        from bz2 import BZ2File
 
251
        tf = TarFile('../first.tar.tbz2', 
 
252
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
253
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
254
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
255
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
256
        tf = TarFile('../first2.tar')
 
257
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
258
 
 
259
    def test_diff(self):
 
260
        self.example_branch()
 
261
        file('hello', 'wt').write('hello world!')
 
262
        self.runbzr('commit -m fixing hello')
 
263
        output = self.runbzr('diff -r 2..3', backtick=1)
 
264
        self.assert_('\n+hello world!' in output)
 
265
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
266
        self.assert_('\n+baz' in output)
 
267
 
 
268
    def test_branch(self):
 
269
        """Branch from one branch to another."""
143
270
        os.mkdir('a')
144
271
        os.chdir('a')
145
 
 
146
 
        bzr = self.runbzr
147
272
        self.example_branch()
148
 
 
149
273
        os.chdir('..')
150
 
        bzr('branch a b')
 
274
        self.runbzr('branch a b')
 
275
        self.runbzr('branch a c -r 1')
151
276
        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)
 
277
        self.runbzr('commit -m foo --unchanged')
 
278
        os.chdir('..')
 
279
        # naughty - abstraction violations RBC 20050928  
 
280
        print "test_branch used to delete the stores, how is this meant to work ?"
 
281
        #shutil.rmtree('a/.bzr/revision-store')
 
282
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
283
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
284
        self.runbzr('branch a d --basis b')
 
285
 
 
286
    def test_merge(self):
 
287
        from bzrlib.branch import Branch
181
288
        
 
289
        os.mkdir('a')
 
290
        os.chdir('a')
 
291
        self.example_branch()
 
292
        os.chdir('..')
 
293
        self.runbzr('branch a b')
 
294
        os.chdir('b')
 
295
        file('goodbye', 'wt').write('quux')
 
296
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
297
 
 
298
        os.chdir('../a')
 
299
        file('hello', 'wt').write('quuux')
 
300
        # We can't merge when there are in-tree changes
 
301
        self.runbzr('merge ../b', retcode=1)
 
302
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
303
        self.runbzr('merge ../b')
 
304
        self.check_file_contents('goodbye', 'quux')
 
305
        # Merging a branch pulls its revision into the tree
 
306
        a = Branch.open('.')
 
307
        b = Branch.open('../b')
 
308
        a.get_revision_xml(b.last_revision())
 
309
        self.log('pending merges: %s', a.pending_merges())
 
310
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
311
        #        % (a.pending_merges(), b.last_patch())
 
312
 
 
313
    def test_merge_with_missing_file(self):
 
314
        """Merge handles missing file conflicts"""
 
315
        os.mkdir('a')
 
316
        os.chdir('a')
 
317
        os.mkdir('sub')
 
318
        print >> file('sub/a.txt', 'wb'), "hello"
 
319
        print >> file('b.txt', 'wb'), "hello"
 
320
        print >> file('sub/c.txt', 'wb'), "hello"
 
321
        self.runbzr('init')
 
322
        self.runbzr('add')
 
323
        self.runbzr(('commit', '-m', 'added a'))
 
324
        self.runbzr('branch . ../b')
 
325
        print >> file('sub/a.txt', 'ab'), "there"
 
326
        print >> file('b.txt', 'ab'), "there"
 
327
        print >> file('sub/c.txt', 'ab'), "there"
 
328
        self.runbzr(('commit', '-m', 'Added there'))
 
329
        os.unlink('sub/a.txt')
 
330
        os.unlink('sub/c.txt')
 
331
        os.rmdir('sub')
 
332
        os.unlink('b.txt')
 
333
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
334
        os.chdir('../b')
 
335
        print >> file('sub/a.txt', 'ab'), "something"
 
336
        print >> file('b.txt', 'ab'), "something"
 
337
        print >> file('sub/c.txt', 'ab'), "something"
 
338
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
339
        self.runbzr('merge ../a/')
 
340
        assert os.path.exists('sub/a.txt.THIS')
 
341
        assert os.path.exists('sub/a.txt.BASE')
 
342
        os.chdir('../a')
 
343
        self.runbzr('merge ../b/')
 
344
        assert os.path.exists('sub/a.txt.OTHER')
 
345
        assert os.path.exists('sub/a.txt.BASE')
 
346
 
 
347
    def test_merge_with_missing_file(self):
 
348
        """Merge handles missing file conflicts"""
 
349
        os.mkdir('a')
 
350
        os.chdir('a')
 
351
        os.mkdir('sub')
 
352
        print >> file('sub/a.txt', 'wb'), "hello"
 
353
        print >> file('b.txt', 'wb'), "hello"
 
354
        print >> file('sub/c.txt', 'wb'), "hello"
 
355
        self.runbzr('init')
 
356
        self.runbzr('add')
 
357
        self.runbzr(('commit', '-m', 'added a'))
 
358
        self.runbzr('branch . ../b')
 
359
        print >> file('sub/a.txt', 'ab'), "there"
 
360
        print >> file('b.txt', 'ab'), "there"
 
361
        print >> file('sub/c.txt', 'ab'), "there"
 
362
        self.runbzr(('commit', '-m', 'Added there'))
 
363
        os.unlink('sub/a.txt')
 
364
        os.unlink('sub/c.txt')
 
365
        os.rmdir('sub')
 
366
        os.unlink('b.txt')
 
367
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
368
        os.chdir('../b')
 
369
        print >> file('sub/a.txt', 'ab'), "something"
 
370
        print >> file('b.txt', 'ab'), "something"
 
371
        print >> file('sub/c.txt', 'ab'), "something"
 
372
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
373
        self.runbzr('merge ../a/')
 
374
        assert os.path.exists('sub/a.txt.THIS')
 
375
        assert os.path.exists('sub/a.txt.BASE')
 
376
        os.chdir('../a')
 
377
        self.runbzr('merge ../b/')
 
378
        assert os.path.exists('sub/a.txt.OTHER')
 
379
        assert os.path.exists('sub/a.txt.BASE')
 
380
 
 
381
    def test_pull(self):
 
382
        """Pull changes from one branch to another."""
 
383
        os.mkdir('a')
 
384
        os.chdir('a')
 
385
 
 
386
        self.example_branch()
 
387
        self.runbzr('pull', retcode=1)
 
388
        self.runbzr('missing', retcode=1)
 
389
        self.runbzr('missing .')
 
390
        self.runbzr('missing')
 
391
        self.runbzr('pull')
 
392
        self.runbzr('pull /', retcode=1)
 
393
        self.runbzr('pull')
 
394
 
 
395
        os.chdir('..')
 
396
        self.runbzr('branch a b')
 
397
        os.chdir('b')
 
398
        self.runbzr('pull')
 
399
        os.mkdir('subdir')
 
400
        self.runbzr('add subdir')
 
401
        self.runbzr('commit -m blah --unchanged')
 
402
        os.chdir('../a')
 
403
        a = Branch.open('.')
 
404
        b = Branch.open('../b')
 
405
        assert a.revision_history() == b.revision_history()[:-1]
 
406
        self.runbzr('pull ../b')
 
407
        assert a.revision_history() == b.revision_history()
 
408
        self.runbzr('commit -m blah2 --unchanged')
 
409
        os.chdir('../b')
 
410
        self.runbzr('commit -m blah3 --unchanged')
 
411
        self.runbzr('pull ../a', retcode=1)
 
412
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
413
        return
 
414
        os.chdir('../a')
 
415
        self.runbzr('merge ../b')
 
416
        self.runbzr('commit -m blah4 --unchanged')
 
417
        os.chdir('../b/subdir')
 
418
        self.runbzr('pull ../../a')
 
419
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
420
        self.runbzr('commit -m blah5 --unchanged')
 
421
        self.runbzr('commit -m blah6 --unchanged')
 
422
        os.chdir('..')
 
423
        self.runbzr('pull ../a')
 
424
        os.chdir('../a')
 
425
        self.runbzr('commit -m blah7 --unchanged')
 
426
        self.runbzr('merge ../b')
 
427
        self.runbzr('commit -m blah8 --unchanged')
 
428
        self.runbzr('pull ../b')
 
429
        self.runbzr('pull ../b')
 
430
 
182
431
    def test_locations(self):
183
432
        """Using and remembering different locations"""
184
433
        os.mkdir('a')
185
434
        os.chdir('a')
186
435
        self.runbzr('init')
187
436
        self.runbzr('commit -m unchanged --unchanged')
188
 
        self.runbzr('pull', retcode=3)
189
 
        self.runbzr('merge', retcode=3)
 
437
        self.runbzr('pull', retcode=1)
 
438
        self.runbzr('merge', retcode=1)
190
439
        self.runbzr('branch . ../b')
191
440
        os.chdir('../b')
192
441
        self.runbzr('pull')
198
447
        self.runbzr('pull')
199
448
        self.runbzr('pull ../c')
200
449
        self.runbzr('branch ../c ../d')
201
 
        osutils.rmtree('../c')
 
450
        shutil.rmtree('../c')
202
451
        self.runbzr('pull')
203
452
        os.chdir('../b')
204
453
        self.runbzr('pull')
205
454
        os.chdir('../d')
206
 
        self.runbzr('pull', retcode=3)
 
455
        self.runbzr('pull', retcode=1)
207
456
        self.runbzr('pull ../a --remember')
208
457
        self.runbzr('pull')
209
458
        
 
459
    def test_add_reports(self):
 
460
        """add command prints the names of added files."""
 
461
        b = Branch.initialize('.')
 
462
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
463
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
464
        # the ordering is not defined at the moment
 
465
        results = sorted(out.rstrip('\n').split('\n'))
 
466
        self.assertEquals(['added dir',
 
467
                           'added dir'+os.sep+'sub.txt',
 
468
                           'added top.txt',],
 
469
                          results)
 
470
 
210
471
    def test_unknown_command(self):
211
472
        """Handling of unknown command."""
212
473
        out, err = self.run_bzr_captured(['fluffy-badger'],
213
 
                                         retcode=3)
 
474
                                         retcode=1)
214
475
        self.assertEquals(out, '')
215
476
        err.index('unknown command')
216
477
 
217
 
    def create_conflicts(self):
218
 
        """Create a conflicted tree"""
 
478
    def test_conflicts(self):
 
479
        """Handling of merge conflicts"""
219
480
        os.mkdir('base')
220
481
        os.chdir('base')
221
482
        file('hello', 'wb').write("hi world")
235
496
        file('question', 'wb').write("What do you get when you multiply six"
236
497
                                   "times nine?")
237
498
        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)
 
499
        self.runbzr('merge ../other')
271
500
        result = self.runbzr('conflicts', backtick=1)
272
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
273
 
                                  " question\n")
 
501
        self.assertEquals(result, "hello\nquestion\n")
274
502
        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)
 
503
        assert "conflicts:\n  hello\n  question\n" in result, result
277
504
        self.runbzr('resolve hello')
278
505
        result = self.runbzr('conflicts', backtick=1)
279
 
        self.assertEquals(result, "Text conflict in question\n")
280
 
        self.runbzr('commit -m conflicts', retcode=3)
 
506
        self.assertEquals(result, "question\n")
 
507
        self.runbzr('commit -m conflicts', retcode=1)
281
508
        self.runbzr('resolve --all')
282
509
        result = self.runbzr('conflicts', backtick=1)
283
510
        self.runbzr('commit -m conflicts')
284
511
        self.assertEquals(result, "")
285
512
 
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
513
def listdir_sorted(dir):
376
514
    L = os.listdir(dir)
377
515
    L.sort()
395
533
        runbzr('init')
396
534
 
397
535
        self.assertEquals(capture('root').rstrip(),
398
 
                          pathjoin(self.test_dir, 'branch1'))
 
536
                          os.path.join(self.test_dir, 'branch1'))
399
537
 
400
538
        progress("status of new file")
401
539
 
406
544
        self.assertEquals(capture('unknowns'), 'test.txt\n')
407
545
 
408
546
        out = capture("status")
409
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
547
        assert out == 'unknown:\n  test.txt\n'
 
548
 
 
549
        out = capture("status --all")
 
550
        assert out == "unknown:\n  test.txt\n"
 
551
 
 
552
        out = capture("status test.txt --all")
 
553
        assert out == "unknown:\n  test.txt\n"
410
554
 
411
555
        f = file('test2.txt', 'wt')
412
556
        f.write('goodbye cruel world...\n')
413
557
        f.close()
414
558
 
415
559
        out = capture("status test.txt")
416
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
560
        assert out == "unknown:\n  test.txt\n"
417
561
 
418
562
        out = capture("status")
419
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
563
        assert out == ("unknown:\n"
 
564
                       "  test.txt\n"
 
565
                       "  test2.txt\n")
420
566
 
421
567
        os.unlink('test2.txt')
422
568
 
423
569
        progress("command aliases")
424
 
        out = capture("st")
425
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
570
        out = capture("st --all")
 
571
        assert out == ("unknown:\n"
 
572
                       "  test.txt\n")
426
573
 
427
574
        out = capture("stat")
428
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
575
        assert out == ("unknown:\n"
 
576
                       "  test.txt\n")
429
577
 
430
578
        progress("command help")
431
579
        runbzr("help st")
432
580
        runbzr("help")
433
581
        runbzr("help commands")
434
 
        runbzr("help slartibartfast", 3)
 
582
        runbzr("help slartibartfast", 1)
435
583
 
436
584
        out = capture("help ci")
437
 
        out.index('aliases: ci, checkin\n')
 
585
        out.index('aliases: ')
 
586
 
 
587
        progress("can't rename unversioned file")
 
588
        runbzr("rename test.txt new-test.txt", 1)
 
589
 
 
590
        progress("adding a file")
 
591
 
 
592
        runbzr("add test.txt")
 
593
        assert capture("unknowns") == ''
 
594
        assert capture("status --all") == ("added:\n"
 
595
                                                "  test.txt\n")
 
596
 
 
597
        progress("rename newly-added file")
 
598
        runbzr("rename test.txt hello.txt")
 
599
        assert os.path.exists("hello.txt")
 
600
        assert not os.path.exists("test.txt")
 
601
 
 
602
        assert capture("revno") == '0\n'
 
603
 
 
604
        progress("add first revision")
 
605
        runbzr(['commit', '-m', 'add first revision'])
 
606
 
 
607
        progress("more complex renames")
 
608
        os.mkdir("sub1")
 
609
        runbzr("rename hello.txt sub1", 1)
 
610
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
611
        runbzr("move hello.txt sub1", 1)
 
612
 
 
613
        runbzr("add sub1")
 
614
        runbzr("rename sub1 sub2")
 
615
        runbzr("move hello.txt sub2")
 
616
        assert capture("relpath sub2/hello.txt") == 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')
438
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
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
656
        f.write('this is my new commit\n')
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" 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
 
        log_out = capture('log --line')
466
 
        # determine the widest line we want
467
 
        max_width = terminal_width() - 1
468
 
        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)
472
675
 
473
676
        progress("file with spaces in name")
474
677
        mkdir('sub directory')
475
678
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
476
679
        runbzr('add .')
477
 
        runbzr('diff', retcode=1)
 
680
        runbzr('diff')
478
681
        runbzr('commit -m add-spaces')
479
682
        runbzr('check')
480
683
 
490
693
            runbzr('init')
491
694
            os.symlink("NOWHERE1", "link1")
492
695
            runbzr('add link1')
493
 
            self.assertEquals(self.capture('unknowns'), '')
 
696
            assert self.capture('unknowns') == ''
494
697
            runbzr(['commit', '-m', '1: added symlink link1'])
495
698
    
496
699
            mkdir('d1')
497
700
            runbzr('add d1')
498
 
            self.assertEquals(self.capture('unknowns'), '')
 
701
            assert self.capture('unknowns') == ''
499
702
            os.symlink("NOWHERE2", "d1/link2")
500
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
 
703
            assert self.capture('unknowns') == 'd1/link2\n'
501
704
            # is d1/link2 found when adding d1
502
705
            runbzr('add d1')
503
 
            self.assertEquals(self.capture('unknowns'), '')
 
706
            assert self.capture('unknowns') == ''
504
707
            os.symlink("NOWHERE3", "d1/link3")
505
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
708
            assert self.capture('unknowns') == 'd1/link3\n'
506
709
            runbzr(['commit', '-m', '2: added dir, symlink'])
507
710
    
508
711
            runbzr('rename d1 d2')
509
712
            runbzr('move d2/link2 .')
510
713
            runbzr('move link1 d2')
511
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
512
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
714
            assert os.readlink("./link2") == "NOWHERE2"
 
715
            assert os.readlink("d2/link1") == "NOWHERE1"
513
716
            runbzr('add d2/link3')
514
 
            runbzr('diff', retcode=1)
 
717
            runbzr('diff')
515
718
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
516
719
    
517
720
            os.unlink("link2")
518
721
            os.symlink("TARGET 2", "link2")
519
722
            os.unlink("d2/link1")
520
723
            os.symlink("TARGET 1", "d2/link1")
521
 
            runbzr('diff', retcode=1)
522
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
724
            runbzr('diff')
 
725
            assert self.capture("relpath d2/link1") == "d2/link1\n"
523
726
            runbzr(['commit', '-m', '4: retarget of two links'])
524
727
    
525
 
            runbzr('remove --keep d2/link1')
526
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
728
            runbzr('remove d2/link1')
 
729
            assert self.capture('unknowns') == 'd2/link1\n'
527
730
            runbzr(['commit', '-m', '5: remove d2/link1'])
528
 
            # try with the rm alias
529
 
            runbzr('add d2/link1')
530
 
            runbzr(['commit', '-m', '6: add d2/link1'])
531
 
            runbzr('rm --keep d2/link1')
532
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
533
 
            runbzr(['commit', '-m', '7: remove d2/link1'])
534
731
    
535
732
            os.mkdir("d1")
536
733
            runbzr('add d1')
537
734
            runbzr('rename d2/link3 d1/link3new')
538
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
539
 
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
735
            assert self.capture('unknowns') == 'd2/link1\n'
 
736
            runbzr(['commit', '-m', '6: remove d2/link1, move/rename link3'])
540
737
            
541
738
            runbzr(['check'])
542
739
            
543
740
            runbzr(['export', '-r', '1', 'exp1.tmp'])
544
741
            chdir("exp1.tmp")
545
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
546
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
742
            assert listdir_sorted(".") == [ "link1" ]
 
743
            assert os.readlink("link1") == "NOWHERE1"
547
744
            chdir("..")
548
745
            
549
746
            runbzr(['export', '-r', '2', 'exp2.tmp'])
550
747
            chdir("exp2.tmp")
551
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
748
            assert listdir_sorted(".") == [ "d1", "link1" ]
552
749
            chdir("..")
553
750
            
554
751
            runbzr(['export', '-r', '3', 'exp3.tmp'])
555
752
            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")
 
753
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
754
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
755
            assert os.readlink("d2/link1") == "NOWHERE1"
 
756
            assert os.readlink("link2")    == "NOWHERE2"
560
757
            chdir("..")
561
758
            
562
759
            runbzr(['export', '-r', '4', 'exp4.tmp'])
563
760
            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" ])
 
761
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
762
            assert os.readlink("d2/link1") == "TARGET 1"
 
763
            assert os.readlink("link2")    == "TARGET 2"
 
764
            assert listdir_sorted("d2") == [ "link1", "link3" ]
568
765
            chdir("..")
569
766
            
570
767
            runbzr(['export', '-r', '5', 'exp5.tmp'])
571
768
            chdir("exp5.tmp")
572
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
573
 
            self.assert_(os.path.islink("link2"))
574
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
769
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
770
            assert os.path.islink("link2")
 
771
            assert listdir_sorted("d2")== [ "link3" ]
575
772
            chdir("..")
576
773
            
577
 
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
774
            runbzr(['export', '-r', '6', 'exp6.tmp'])
578
775
            chdir("exp6.tmp")
579
 
            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")
 
776
            assert listdir_sorted(".") == [ "d1", "d2", "link2" ]
 
777
            assert listdir_sorted("d1") == [ "link3new" ]
 
778
            assert listdir_sorted("d2") == []
 
779
            assert os.readlink("d1/link3new") == "NOWHERE3"
583
780
            chdir("..")
584
781
        else:
585
782
            progress("skipping symlink tests")
586
783
 
587
784
 
588
 
class RemoteTests(object):
 
785
class HttpTests(TestCaseWithWebserver):
589
786
    """Test bzr ui commands against remote branches."""
590
787
 
591
788
    def test_branch(self):
592
789
        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')
 
790
        branch = Branch.initialize('from')
 
791
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
792
        url = self.get_remote_url('from')
597
793
        self.run_bzr('branch', url, 'to')
598
794
        branch = Branch.open('to')
599
795
        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