/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

Exclude more files from dumb-rsync upload

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
# Mr. Smoketoomuch: I'm sorry?
18
 
# Mr. Bounder: You'd better cut down a little then.
19
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
20
 
#                   then!
21
18
 
22
19
"""Black-box tests for bzr.
23
20
 
24
21
These check that it behaves properly when it's invoked through the regular
25
 
command-line interface. This doesn't actually run a new interpreter but
 
22
command-line interface. This doesn't actually run a new interpreter but 
26
23
rather starts again from the run_bzr function.
27
24
"""
28
25
 
29
26
 
30
27
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
31
28
# Note: Please don't add new tests here, it's too big and bulky.  Instead add
32
 
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
33
 
# UI command/aspect that is being tested.
 
29
# them into small suites for the particular function that's tested.
34
30
 
35
31
 
36
32
from cStringIO import StringIO
37
33
import os
38
34
import re
 
35
import shutil
39
36
import sys
40
37
 
41
 
import bzrlib
42
 
from bzrlib import (
43
 
    osutils,
44
 
    )
45
38
from bzrlib.branch import Branch
 
39
from bzrlib.clone import copy_branch
46
40
from bzrlib.errors import BzrCommandError
47
 
from bzrlib.tests.http_utils import TestCaseWithWebserver
48
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
49
 
from bzrlib.tests.blackbox import ExternalBase
50
 
from bzrlib.workingtree import WorkingTree
 
41
from bzrlib.osutils import has_symlinks
 
42
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
43
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
44
 
 
45
 
 
46
class ExternalBase(TestCaseInTempDir):
 
47
 
 
48
    def runbzr(self, args, retcode=0, backtick=False):
 
49
        if isinstance(args, basestring):
 
50
            args = args.split()
 
51
 
 
52
        if backtick:
 
53
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
54
        else:
 
55
            return self.run_bzr_captured(args, retcode=retcode)
51
56
 
52
57
 
53
58
class TestCommands(ExternalBase):
54
59
 
 
60
    def test_help_commands(self):
 
61
        self.runbzr('--help')
 
62
        self.runbzr('help')
 
63
        self.runbzr('help commands')
 
64
        self.runbzr('help help')
 
65
        self.runbzr('commit -h')
 
66
 
 
67
    def test_init_branch(self):
 
68
        self.runbzr(['init'])
 
69
 
 
70
        # Can it handle subdirectories as well?
 
71
        self.runbzr('init subdir1')
 
72
        self.assert_(os.path.exists('subdir1'))
 
73
        self.assert_(os.path.exists('subdir1/.bzr'))
 
74
 
 
75
        self.runbzr('init subdir2/nothere', retcode=3)
 
76
        
 
77
        os.mkdir('subdir2')
 
78
        self.runbzr('init subdir2')
 
79
        self.runbzr('init subdir2', retcode=3)
 
80
 
 
81
        self.runbzr('init subdir2/subsubdir1')
 
82
        self.assert_(os.path.exists('subdir2/subsubdir1/.bzr'))
 
83
 
 
84
    def test_whoami(self):
 
85
        # this should always identify something, if only "john@localhost"
 
86
        self.runbzr("whoami")
 
87
        self.runbzr("whoami --email")
 
88
 
 
89
        self.assertEquals(self.runbzr("whoami --email",
 
90
                                      backtick=True).count('@'), 1)
 
91
        
 
92
    def test_whoami_branch(self):
 
93
        """branch specific user identity works."""
 
94
        self.runbzr('init')
 
95
        f = file('.bzr/email', 'wt')
 
96
        f.write('Branch Identity <branch@identi.ty>')
 
97
        f.close()
 
98
        bzr_email = os.environ.get('BZREMAIL')
 
99
        if bzr_email is not None:
 
100
            del os.environ['BZREMAIL']
 
101
        whoami = self.runbzr("whoami",backtick=True)
 
102
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
103
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
104
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
105
        # Verify that the environment variable overrides the value 
 
106
        # in the file
 
107
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
108
        whoami = self.runbzr("whoami",backtick=True)
 
109
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
110
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
111
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
112
        if bzr_email is not None:
 
113
            os.environ['BZREMAIL'] = bzr_email
 
114
 
 
115
    def test_nick_command(self):
 
116
        """bzr nick for viewing, setting nicknames"""
 
117
        os.mkdir('me.dev')
 
118
        os.chdir('me.dev')
 
119
        self.runbzr('init')
 
120
        nick = self.runbzr("nick",backtick=True)
 
121
        self.assertEqual(nick, 'me.dev\n')
 
122
        nick = self.runbzr("nick moo")
 
123
        nick = self.runbzr("nick",backtick=True)
 
124
        self.assertEqual(nick, 'moo\n')
 
125
 
 
126
 
55
127
    def test_invalid_commands(self):
56
 
        self.run_bzr("pants", retcode=3)
57
 
        self.run_bzr("--pants off", retcode=3)
58
 
        self.run_bzr("diff --message foo", retcode=3)
 
128
        self.runbzr("pants", retcode=3)
 
129
        self.runbzr("--pants off", retcode=3)
 
130
        self.runbzr("diff --message foo", retcode=3)
 
131
 
 
132
    def test_empty_commit(self):
 
133
        self.runbzr("init")
 
134
        self.build_tree(['hello.txt'])
 
135
        self.runbzr("commit -m empty", retcode=3)
 
136
        self.runbzr("add hello.txt")
 
137
        self.runbzr("commit -m added")       
 
138
 
 
139
    def test_empty_commit_message(self):
 
140
        self.runbzr("init")
 
141
        file('foo.c', 'wt').write('int main() {}')
 
142
        self.runbzr(['add', 'foo.c'])
 
143
        self.runbzr(["commit", "-m", ""] , retcode=3) 
 
144
 
 
145
    def test_remove_deleted(self):
 
146
        self.runbzr("init")
 
147
        self.build_tree(['a'])
 
148
        self.runbzr(['add', 'a'])
 
149
        self.runbzr(['commit', '-m', 'added a'])
 
150
        os.unlink('a')
 
151
        self.runbzr(['remove', 'a'])
 
152
 
 
153
    def test_other_branch_commit(self):
 
154
        # this branch is to ensure consistent behaviour, whether we're run
 
155
        # inside a branch, or not.
 
156
        os.mkdir('empty_branch')
 
157
        os.chdir('empty_branch')
 
158
        self.runbzr('init')
 
159
        os.mkdir('branch')
 
160
        os.chdir('branch')
 
161
        self.runbzr('init')
 
162
        file('foo.c', 'wt').write('int main() {}')
 
163
        file('bar.c', 'wt').write('int main() {}')
 
164
        os.chdir('..')
 
165
        self.runbzr(['add', 'branch/foo.c'])
 
166
        self.runbzr(['add', 'branch'])
 
167
        # can't commit files in different trees; sane error
 
168
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
 
169
        self.runbzr('commit -m newstuff branch/foo.c')
 
170
        self.runbzr('commit -m newstuff branch')
 
171
        self.runbzr('commit -m newstuff branch', retcode=3)
 
172
 
 
173
 
 
174
    def test_ignore_patterns(self):
 
175
        from bzrlib.branch import Branch
 
176
        
 
177
        b = Branch.initialize('.')
 
178
        self.assertEquals(list(b.unknowns()), [])
 
179
 
 
180
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
181
        self.assertEquals(list(b.unknowns()), [])
 
182
        self.assertEquals(self.capture('unknowns'), '')
 
183
 
 
184
        file('foo.c', 'wt').write('int main() {}')
 
185
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
186
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
 
187
 
 
188
        self.runbzr(['add', 'foo.c'])
 
189
        self.assertEquals(self.capture('unknowns'), '')
 
190
 
 
191
        # 'ignore' works when creating the .bzignore file
 
192
        file('foo.blah', 'wt').write('blah')
 
193
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
194
        self.runbzr('ignore *.blah')
 
195
        self.assertEquals(list(b.unknowns()), [])
 
196
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
 
197
 
 
198
        # 'ignore' works when then .bzrignore file already exists
 
199
        file('garh', 'wt').write('garh')
 
200
        self.assertEquals(list(b.unknowns()), ['garh'])
 
201
        self.assertEquals(self.capture('unknowns'), 'garh\n')
 
202
        self.runbzr('ignore garh')
 
203
        self.assertEquals(list(b.unknowns()), [])
 
204
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
59
205
 
60
206
    def test_revert(self):
61
 
        self.run_bzr('init')
 
207
        self.runbzr('init')
62
208
 
63
209
        file('hello', 'wt').write('foo')
64
 
        self.run_bzr('add hello')
65
 
        self.run_bzr('commit -m setup hello')
 
210
        self.runbzr('add hello')
 
211
        self.runbzr('commit -m setup hello')
66
212
 
67
213
        file('goodbye', 'wt').write('baz')
68
 
        self.run_bzr('add goodbye')
69
 
        self.run_bzr('commit -m setup goodbye')
 
214
        self.runbzr('add goodbye')
 
215
        self.runbzr('commit -m setup goodbye')
70
216
 
71
217
        file('hello', 'wt').write('bar')
72
218
        file('goodbye', 'wt').write('qux')
73
 
        self.run_bzr('revert hello')
 
219
        self.runbzr('revert hello')
74
220
        self.check_file_contents('hello', 'foo')
75
221
        self.check_file_contents('goodbye', 'qux')
76
 
        self.run_bzr('revert')
 
222
        self.runbzr('revert')
77
223
        self.check_file_contents('goodbye', 'baz')
78
224
 
79
225
        os.mkdir('revertdir')
80
 
        self.run_bzr('add revertdir')
81
 
        self.run_bzr('commit -m f')
 
226
        self.runbzr('add revertdir')
 
227
        self.runbzr('commit -m f')
82
228
        os.rmdir('revertdir')
83
 
        self.run_bzr('revert')
84
 
 
85
 
        if osutils.has_symlinks():
86
 
            os.symlink('/unlikely/to/exist', 'symlink')
87
 
            self.run_bzr('add symlink')
88
 
            self.run_bzr('commit -m f')
89
 
            os.unlink('symlink')
90
 
            self.run_bzr('revert')
91
 
            self.failUnlessExists('symlink')
92
 
            os.unlink('symlink')
93
 
            os.symlink('a-different-path', 'symlink')
94
 
            self.run_bzr('revert')
95
 
            self.assertEqual('/unlikely/to/exist',
96
 
                             os.readlink('symlink'))
97
 
        else:
98
 
            self.log("skipping revert symlink tests")
99
 
 
 
229
        self.runbzr('revert')
 
230
 
 
231
        os.symlink('/unlikely/to/exist', 'symlink')
 
232
        self.runbzr('add symlink')
 
233
        self.runbzr('commit -m f')
 
234
        os.unlink('symlink')
 
235
        self.runbzr('revert')
 
236
        self.failUnlessExists('symlink')
 
237
        os.unlink('symlink')
 
238
        os.symlink('a-different-path', 'symlink')
 
239
        self.runbzr('revert')
 
240
        self.assertEqual('/unlikely/to/exist',
 
241
                         os.readlink('symlink'))
 
242
        
100
243
        file('hello', 'wt').write('xyz')
101
 
        self.run_bzr('commit -m xyz hello')
102
 
        self.run_bzr('revert -r 1 hello')
 
244
        self.runbzr('commit -m xyz hello')
 
245
        self.runbzr('revert -r 1 hello')
103
246
        self.check_file_contents('hello', 'foo')
104
 
        self.run_bzr('revert hello')
 
247
        self.runbzr('revert hello')
105
248
        self.check_file_contents('hello', 'xyz')
106
249
        os.chdir('revertdir')
107
 
        self.run_bzr('revert')
 
250
        self.runbzr('revert')
108
251
        os.chdir('..')
109
252
 
 
253
    def test_status(self):
 
254
        self.runbzr("init")
 
255
        self.build_tree(['hello.txt'])
 
256
        result = self.runbzr("status")
 
257
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
258
        self.runbzr("add hello.txt")
 
259
        result = self.runbzr("status")
 
260
        self.assert_("added:\n  hello.txt\n" in result, result)
 
261
        self.runbzr("commit -m added")
 
262
        result = self.runbzr("status -r 0..1")
 
263
        self.assert_("added:\n  hello.txt\n" in result, result)
 
264
        self.build_tree(['world.txt'])
 
265
        result = self.runbzr("status -r 0")
 
266
        self.assert_("added:\n  hello.txt\n" \
 
267
                     "unknown:\n  world.txt\n" in result, result)
 
268
 
 
269
    def test_mv_modes(self):
 
270
        """Test two modes of operation for mv"""
 
271
        from bzrlib.branch import Branch
 
272
        b = Branch.initialize('.')
 
273
        self.build_tree(['a', 'c', 'subdir/'])
 
274
        self.run_bzr_captured(['add', self.test_dir])
 
275
        self.run_bzr_captured(['mv', 'a', 'b'])
 
276
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
277
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
278
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
279
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
280
 
 
281
    def test_main_version(self):
 
282
        """Check output from version command and master option is reasonable"""
 
283
        # output is intentionally passed through to stdout so that we
 
284
        # can see the version being tested
 
285
        output = self.runbzr('version', backtick=1)
 
286
        self.log('bzr version output:')
 
287
        self.log(output)
 
288
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
289
        self.assertNotEqual(output.index('Canonical'), -1)
 
290
        # make sure --version is consistent
 
291
        tmp_output = self.runbzr('--version', backtick=1)
 
292
        self.log('bzr --version output:')
 
293
        self.log(tmp_output)
 
294
        self.assertEquals(output, tmp_output)
 
295
 
110
296
    def example_branch(test):
111
 
        test.run_bzr('init')
 
297
        test.runbzr('init')
112
298
        file('hello', 'wt').write('foo')
113
 
        test.run_bzr('add hello')
114
 
        test.run_bzr('commit -m setup hello')
 
299
        test.runbzr('add hello')
 
300
        test.runbzr('commit -m setup hello')
115
301
        file('goodbye', 'wt').write('baz')
116
 
        test.run_bzr('add goodbye')
117
 
        test.run_bzr('commit -m setup goodbye')
 
302
        test.runbzr('add goodbye')
 
303
        test.runbzr('commit -m setup goodbye')
 
304
 
 
305
    def test_export(self):
 
306
        os.mkdir('branch')
 
307
        os.chdir('branch')
 
308
        self.example_branch()
 
309
        self.runbzr('export ../latest')
 
310
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
311
        self.runbzr('export ../first -r 1')
 
312
        self.assert_(not os.path.exists('../first/goodbye'))
 
313
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
314
        self.runbzr('export ../first.gz -r 1')
 
315
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
316
        self.runbzr('export ../first.bz2 -r 1')
 
317
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
318
        self.runbzr('export ../first.tar -r 1')
 
319
        self.assert_(os.path.isfile('../first.tar'))
 
320
        from tarfile import TarFile
 
321
        tf = TarFile('../first.tar')
 
322
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
 
323
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
324
        self.runbzr('export ../first.tar.gz -r 1')
 
325
        self.assert_(os.path.isfile('../first.tar.gz'))
 
326
        self.runbzr('export ../first.tbz2 -r 1')
 
327
        self.assert_(os.path.isfile('../first.tbz2'))
 
328
        self.runbzr('export ../first.tar.bz2 -r 1')
 
329
        self.assert_(os.path.isfile('../first.tar.bz2'))
 
330
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
331
        self.assert_(os.path.isfile('../first.tar.tbz2'))
 
332
        from bz2 import BZ2File
 
333
        tf = TarFile('../first.tar.tbz2', 
 
334
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
335
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
 
336
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
337
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
338
        tf = TarFile('../first2.tar')
 
339
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
 
340
 
 
341
    def test_diff(self):
 
342
        self.example_branch()
 
343
        file('hello', 'wt').write('hello world!')
 
344
        self.runbzr('commit -m fixing hello')
 
345
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
 
346
        self.assert_('\n+hello world!' in output)
 
347
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
 
348
        self.assert_('\n+baz' in output)
 
349
        file('moo', 'wb').write('moo')
 
350
        self.runbzr('add moo')
 
351
        os.unlink('moo')
 
352
        self.runbzr('diff')
 
353
 
 
354
    def test_diff_branches(self):
 
355
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'], line_endings='binary')
 
356
        branch = Branch.initialize('branch1')
 
357
        branch.add(['file'])
 
358
        branch.working_tree().commit('add file')
 
359
        copy_branch(branch, 'branch2')
 
360
        print >> open('branch2/file', 'wb'), 'new content'
 
361
        branch2 = Branch.open('branch2')
 
362
        branch2.working_tree().commit('update file')
 
363
        # should open branch1 and diff against branch2, 
 
364
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
365
                                        'branch1'],
 
366
                                       retcode=1)
 
367
        self.assertEquals(("=== modified file 'file'\n"
 
368
                           "--- file\t\n"
 
369
                           "+++ file\t\n"
 
370
                           "@@ -1,1 +1,1 @@\n"
 
371
                           "-new content\n"
 
372
                           "+contents of branch1/file\n"
 
373
                           "\n", ''), output)
 
374
        output = self.run_bzr_captured(['diff', 'branch2', 'branch1'],
 
375
                                       retcode=1)
 
376
        self.assertEqualDiff(("=== modified file 'file'\n"
 
377
                              "--- file\t\n"
 
378
                              "+++ file\t\n"
 
379
                              "@@ -1,1 +1,1 @@\n"
 
380
                              "-new content\n"
 
381
                              "+contents of branch1/file\n"
 
382
                              "\n", ''), output)
 
383
 
 
384
 
 
385
    def test_branch(self):
 
386
        """Branch from one branch to another."""
 
387
        os.mkdir('a')
 
388
        os.chdir('a')
 
389
        self.example_branch()
 
390
        os.chdir('..')
 
391
        self.runbzr('branch a b')
 
392
        self.assertFileEqual('b\n', 'b/.bzr/branch-name')
 
393
        self.runbzr('branch a c -r 1')
 
394
        os.chdir('b')
 
395
        self.runbzr('commit -m foo --unchanged')
 
396
        os.chdir('..')
 
397
        # naughty - abstraction violations RBC 20050928  
 
398
        print "test_branch used to delete the stores, how is this meant to work ?"
 
399
        #shutil.rmtree('a/.bzr/revision-store')
 
400
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
401
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
402
        self.runbzr('branch a d --basis b')
 
403
 
 
404
    def test_merge(self):
 
405
        from bzrlib.branch import Branch
 
406
        
 
407
        os.mkdir('a')
 
408
        os.chdir('a')
 
409
        self.example_branch()
 
410
        os.chdir('..')
 
411
        self.runbzr('branch a b')
 
412
        os.chdir('b')
 
413
        file('goodbye', 'wt').write('quux')
 
414
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
415
 
 
416
        os.chdir('../a')
 
417
        file('hello', 'wt').write('quuux')
 
418
        # We can't merge when there are in-tree changes
 
419
        self.runbzr('merge ../b', retcode=3)
 
420
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
421
        self.runbzr('merge ../b -r last:1..last:1 --merge-type blooof',
 
422
                    retcode=3)
 
423
        self.runbzr('merge ../b -r last:1..last:1 --merge-type merge3')
 
424
        self.runbzr('revert --no-backup')
 
425
        self.runbzr('merge ../b -r last:1..last:1 --merge-type weave')
 
426
        self.runbzr('revert --no-backup')
 
427
        self.runbzr('merge ../b -r last:1..last:1 --reprocess')
 
428
        self.runbzr('revert --no-backup')
 
429
        self.runbzr('merge ../b -r last:1')
 
430
        self.check_file_contents('goodbye', 'quux')
 
431
        # Merging a branch pulls its revision into the tree
 
432
        a = Branch.open('.')
 
433
        b = Branch.open('../b')
 
434
        a.get_revision_xml(b.last_revision())
 
435
        self.log('pending merges: %s', a.working_tree().pending_merges())
 
436
        self.assertEquals(a.working_tree().pending_merges(),
 
437
                          [b.last_revision()])
 
438
        self.runbzr('commit -m merged')
 
439
        self.runbzr('merge ../b -r last:1')
 
440
        self.assertEqual(Branch.open('.').working_tree().pending_merges(), [])
 
441
 
 
442
    def test_merge_with_missing_file(self):
 
443
        """Merge handles missing file conflicts"""
 
444
        os.mkdir('a')
 
445
        os.chdir('a')
 
446
        os.mkdir('sub')
 
447
        print >> file('sub/a.txt', 'wb'), "hello"
 
448
        print >> file('b.txt', 'wb'), "hello"
 
449
        print >> file('sub/c.txt', 'wb'), "hello"
 
450
        self.runbzr('init')
 
451
        self.runbzr('add')
 
452
        self.runbzr(('commit', '-m', 'added a'))
 
453
        self.runbzr('branch . ../b')
 
454
        print >> file('sub/a.txt', 'ab'), "there"
 
455
        print >> file('b.txt', 'ab'), "there"
 
456
        print >> file('sub/c.txt', 'ab'), "there"
 
457
        self.runbzr(('commit', '-m', 'Added there'))
 
458
        os.unlink('sub/a.txt')
 
459
        os.unlink('sub/c.txt')
 
460
        os.rmdir('sub')
 
461
        os.unlink('b.txt')
 
462
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
463
        os.chdir('../b')
 
464
        print >> file('sub/a.txt', 'ab'), "something"
 
465
        print >> file('b.txt', 'ab'), "something"
 
466
        print >> file('sub/c.txt', 'ab'), "something"
 
467
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
468
        self.runbzr('merge ../a/', retcode=1)
 
469
        self.assert_(os.path.exists('sub/a.txt.THIS'))
 
470
        self.assert_(os.path.exists('sub/a.txt.BASE'))
 
471
        os.chdir('../a')
 
472
        self.runbzr('merge ../b/', retcode=1)
 
473
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
 
474
        self.assert_(os.path.exists('sub/a.txt.BASE'))
 
475
 
 
476
    def test_pull(self):
 
477
        """Pull changes from one branch to another."""
 
478
        os.mkdir('a')
 
479
        os.chdir('a')
 
480
 
 
481
        self.example_branch()
 
482
        self.runbzr('pull', retcode=3)
 
483
        self.runbzr('missing', retcode=3)
 
484
        self.runbzr('missing .')
 
485
        self.runbzr('missing')
 
486
        self.runbzr('pull')
 
487
        self.runbzr('pull /', retcode=3)
 
488
        self.runbzr('pull')
 
489
 
 
490
        os.chdir('..')
 
491
        self.runbzr('branch a b')
 
492
        os.chdir('b')
 
493
        self.runbzr('pull')
 
494
        os.mkdir('subdir')
 
495
        self.runbzr('add subdir')
 
496
        self.runbzr('commit -m blah --unchanged')
 
497
        os.chdir('../a')
 
498
        a = Branch.open('.')
 
499
        b = Branch.open('../b')
 
500
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
 
501
        self.runbzr('pull ../b')
 
502
        self.assertEquals(a.revision_history(), b.revision_history())
 
503
        self.runbzr('commit -m blah2 --unchanged')
 
504
        os.chdir('../b')
 
505
        self.runbzr('commit -m blah3 --unchanged')
 
506
        # no overwrite
 
507
        self.runbzr('pull ../a', retcode=3)
 
508
        os.chdir('..')
 
509
        self.runbzr('branch b overwriteme')
 
510
        os.chdir('overwriteme')
 
511
        self.runbzr('pull --overwrite ../a')
 
512
        overwritten = Branch.open('.')
 
513
        self.assertEqual(overwritten.revision_history(),
 
514
                         a.revision_history())
 
515
        os.chdir('../a')
 
516
        self.runbzr('merge ../b')
 
517
        self.runbzr('commit -m blah4 --unchanged')
 
518
        os.chdir('../b/subdir')
 
519
        self.runbzr('pull ../../a')
 
520
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
 
521
        self.runbzr('commit -m blah5 --unchanged')
 
522
        self.runbzr('commit -m blah6 --unchanged')
 
523
        os.chdir('..')
 
524
        self.runbzr('pull ../a')
 
525
        os.chdir('../a')
 
526
        self.runbzr('commit -m blah7 --unchanged')
 
527
        self.runbzr('merge ../b')
 
528
        self.runbzr('commit -m blah8 --unchanged')
 
529
        self.runbzr('pull ../b')
 
530
        self.runbzr('pull ../b')
 
531
 
 
532
    def test_inventory(self):
 
533
        bzr = self.runbzr
 
534
        def output_equals(value, *args):
 
535
            out = self.runbzr(['inventory'] + list(args), backtick=True)
 
536
            self.assertEquals(out, value)
 
537
 
 
538
        bzr('init')
 
539
        open('a', 'wb').write('hello\n')
 
540
        os.mkdir('b')
 
541
 
 
542
        bzr('add a b')
 
543
        bzr('commit -m add')
 
544
 
 
545
        output_equals('a\n', '--kind', 'file')
 
546
        output_equals('b\n', '--kind', 'directory')        
 
547
 
 
548
    def test_ls(self):
 
549
        """Test the abilities of 'bzr ls'"""
 
550
        bzr = self.runbzr
 
551
        def bzrout(*args, **kwargs):
 
552
            kwargs['backtick'] = True
 
553
            return self.runbzr(*args, **kwargs)
 
554
 
 
555
        def ls_equals(value, *args):
 
556
            out = self.runbzr(['ls'] + list(args), backtick=True)
 
557
            self.assertEquals(out, value)
 
558
 
 
559
        bzr('init')
 
560
        open('a', 'wb').write('hello\n')
 
561
 
 
562
        # Can't supply both
 
563
        bzr('ls --verbose --null', retcode=3)
 
564
 
 
565
        ls_equals('a\n')
 
566
        ls_equals('?        a\n', '--verbose')
 
567
        ls_equals('a\n', '--unknown')
 
568
        ls_equals('', '--ignored')
 
569
        ls_equals('', '--versioned')
 
570
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
 
571
        ls_equals('', '--ignored', '--versioned')
 
572
        ls_equals('a\0', '--null')
 
573
 
 
574
        bzr('add a')
 
575
        ls_equals('V        a\n', '--verbose')
 
576
        bzr('commit -m add')
 
577
        
 
578
        os.mkdir('subdir')
 
579
        ls_equals('V        a\n'
 
580
                  '?        subdir/\n'
 
581
                  , '--verbose')
 
582
        open('subdir/b', 'wb').write('b\n')
 
583
        bzr('add')
 
584
        ls_equals('V        a\n'
 
585
                  'V        subdir/\n'
 
586
                  'V        subdir/b\n'
 
587
                  , '--verbose')
 
588
        bzr('commit -m subdir')
 
589
 
 
590
        ls_equals('a\n'
 
591
                  'subdir\n'
 
592
                  , '--non-recursive')
 
593
 
 
594
        ls_equals('V        a\n'
 
595
                  'V        subdir/\n'
 
596
                  , '--verbose', '--non-recursive')
 
597
 
 
598
        # Check what happens in a sub-directory
 
599
        os.chdir('subdir')
 
600
        ls_equals('b\n')
 
601
        ls_equals('b\0'
 
602
                  , '--null')
 
603
        ls_equals('a\n'
 
604
                  'subdir\n'
 
605
                  'subdir/b\n'
 
606
                  , '--from-root')
 
607
        ls_equals('a\0'
 
608
                  'subdir\0'
 
609
                  'subdir/b\0'
 
610
                  , '--from-root', '--null')
 
611
        ls_equals('a\n'
 
612
                  'subdir\n'
 
613
                  , '--from-root', '--non-recursive')
 
614
 
 
615
        os.chdir('..')
 
616
 
 
617
        # Check what happens when we supply a specific revision
 
618
        ls_equals('a\n', '--revision', '1')
 
619
        ls_equals('V        a\n'
 
620
                  , '--verbose', '--revision', '1')
 
621
 
 
622
        os.chdir('subdir')
 
623
        ls_equals('', '--revision', '1')
 
624
 
 
625
        # Now try to do ignored files.
 
626
        os.chdir('..')
 
627
        open('blah.py', 'wb').write('unknown\n')
 
628
        open('blah.pyo', 'wb').write('ignored\n')
 
629
        ls_equals('a\n'
 
630
                  'blah.py\n'
 
631
                  'blah.pyo\n'
 
632
                  'subdir\n'
 
633
                  'subdir/b\n')
 
634
        ls_equals('V        a\n'
 
635
                  '?        blah.py\n'
 
636
                  'I        blah.pyo\n'
 
637
                  'V        subdir/\n'
 
638
                  'V        subdir/b\n'
 
639
                  , '--verbose')
 
640
        ls_equals('blah.pyo\n'
 
641
                  , '--ignored')
 
642
        ls_equals('blah.py\n'
 
643
                  , '--unknown')
 
644
        ls_equals('a\n'
 
645
                  'subdir\n'
 
646
                  'subdir/b\n'
 
647
                  , '--versioned')
118
648
 
119
649
    def test_pull_verbose(self):
120
650
        """Pull changes from one branch to another and watch the output."""
122
652
        os.mkdir('a')
123
653
        os.chdir('a')
124
654
 
 
655
        bzr = self.runbzr
125
656
        self.example_branch()
126
657
 
127
658
        os.chdir('..')
128
 
        self.run_bzr('branch a b')
 
659
        bzr('branch a b')
129
660
        os.chdir('b')
130
661
        open('b', 'wb').write('else\n')
131
 
        self.run_bzr('add b')
132
 
        self.run_bzr(['commit', '-m', 'added b'])
 
662
        bzr('add b')
 
663
        bzr(['commit', '-m', 'added b'])
133
664
 
134
665
        os.chdir('../a')
135
 
        out = self.run_bzr('pull --verbose ../b')[0]
 
666
        out = bzr('pull --verbose ../b', backtick=True)
136
667
        self.failIfEqual(out.find('Added Revisions:'), -1)
137
668
        self.failIfEqual(out.find('message:\n  added b'), -1)
138
669
        self.failIfEqual(out.find('added b'), -1)
139
670
 
140
671
        # Check that --overwrite --verbose prints out the removed entries
141
 
        self.run_bzr('commit -m foo --unchanged')
 
672
        bzr('commit -m foo --unchanged')
142
673
        os.chdir('../b')
143
 
        self.run_bzr('commit -m baz --unchanged')
144
 
        self.run_bzr('pull ../a', retcode=3)
145
 
        out = self.run_bzr('pull --overwrite --verbose ../a')[0]
 
674
        bzr('commit -m baz --unchanged')
 
675
        bzr('pull ../a', retcode=3)
 
676
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
146
677
 
147
678
        remove_loc = out.find('Removed Revisions:')
148
679
        self.failIfEqual(remove_loc, -1)
156
687
        added_message = out.find('message:\n  foo')
157
688
        self.failIfEqual(added_message, -1)
158
689
        self.failUnless(added_loc < added_message)
159
 
 
 
690
        
160
691
    def test_locations(self):
161
692
        """Using and remembering different locations"""
162
693
        os.mkdir('a')
163
694
        os.chdir('a')
164
 
        self.run_bzr('init')
165
 
        self.run_bzr('commit -m unchanged --unchanged')
166
 
        self.run_bzr('pull', retcode=3)
167
 
        self.run_bzr('merge', retcode=3)
168
 
        self.run_bzr('branch . ../b')
 
695
        self.runbzr('init')
 
696
        self.runbzr('commit -m unchanged --unchanged')
 
697
        self.runbzr('pull', retcode=3)
 
698
        self.runbzr('merge', retcode=3)
 
699
        self.runbzr('branch . ../b')
169
700
        os.chdir('../b')
170
 
        self.run_bzr('pull')
171
 
        self.run_bzr('branch . ../c')
172
 
        self.run_bzr('pull ../c')
173
 
        self.run_bzr('merge')
 
701
        self.runbzr('pull')
 
702
        self.runbzr('branch . ../c')
 
703
        self.runbzr('pull ../c')
 
704
        self.runbzr('merge')
174
705
        os.chdir('../a')
175
 
        self.run_bzr('pull ../b')
176
 
        self.run_bzr('pull')
177
 
        self.run_bzr('pull ../c')
178
 
        self.run_bzr('branch ../c ../d')
179
 
        osutils.rmtree('../c')
180
 
        self.run_bzr('pull')
 
706
        self.runbzr('pull ../b')
 
707
        self.runbzr('pull')
 
708
        self.runbzr('pull ../c')
 
709
        self.runbzr('branch ../c ../d')
 
710
        shutil.rmtree('../c')
 
711
        self.runbzr('pull')
181
712
        os.chdir('../b')
182
 
        self.run_bzr('pull')
 
713
        self.runbzr('pull')
183
714
        os.chdir('../d')
184
 
        self.run_bzr('pull', retcode=3)
185
 
        self.run_bzr('pull ../a --remember')
186
 
        self.run_bzr('pull')
 
715
        self.runbzr('pull', retcode=3)
 
716
        self.runbzr('pull ../a --remember')
 
717
        self.runbzr('pull')
 
718
        
 
719
    def test_add_reports(self):
 
720
        """add command prints the names of added files."""
 
721
        b = Branch.initialize('.')
 
722
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
723
        out = self.run_bzr_captured(['add'], retcode=0)[0]
 
724
        # the ordering is not defined at the moment
 
725
        results = sorted(out.rstrip('\n').split('\n'))
 
726
        self.assertEquals(['added dir',
 
727
                           'added dir'+os.sep+'sub.txt',
 
728
                           'added top.txt',],
 
729
                          results)
 
730
 
 
731
    def test_add_quiet_is(self):
 
732
        """add -q does not print the names of added files."""
 
733
        b = Branch.initialize('.')
 
734
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
735
        out = self.run_bzr_captured(['add', '-q'], retcode=0)[0]
 
736
        # the ordering is not defined at the moment
 
737
        results = sorted(out.rstrip('\n').split('\n'))
 
738
        self.assertEquals([''], results)
187
739
 
188
740
    def test_unknown_command(self):
189
741
        """Handling of unknown command."""
190
 
        out, err = self.run_bzr('fluffy-badger', retcode=3)
 
742
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
743
                                         retcode=3)
191
744
        self.assertEquals(out, '')
192
745
        err.index('unknown command')
193
746
 
197
750
        os.chdir('base')
198
751
        file('hello', 'wb').write("hi world")
199
752
        file('answer', 'wb').write("42")
200
 
        self.run_bzr('init')
201
 
        self.run_bzr('add')
202
 
        self.run_bzr('commit -m base')
203
 
        self.run_bzr('branch . ../other')
204
 
        self.run_bzr('branch . ../this')
 
753
        self.runbzr('init')
 
754
        self.runbzr('add')
 
755
        self.runbzr('commit -m base')
 
756
        self.runbzr('branch . ../other')
 
757
        self.runbzr('branch . ../this')
205
758
        os.chdir('../other')
206
759
        file('hello', 'wb').write("Hello.")
207
760
        file('answer', 'wb').write("Is anyone there?")
208
 
        self.run_bzr('commit -m other')
 
761
        self.runbzr('commit -m other')
209
762
        os.chdir('../this')
210
763
        file('hello', 'wb').write("Hello, world")
211
 
        self.run_bzr('mv answer question')
 
764
        self.runbzr('mv answer question')
212
765
        file('question', 'wb').write("What do you get when you multiply six"
213
766
                                   "times nine?")
214
 
        self.run_bzr('commit -m this')
 
767
        self.runbzr('commit -m this')
215
768
 
216
 
    def test_status(self):
217
 
        os.mkdir('branch1')
218
 
        os.chdir('branch1')
219
 
        self.run_bzr('init')
220
 
        self.run_bzr('commit --unchanged --message f')
221
 
        self.run_bzr('branch . ../branch2')
222
 
        self.run_bzr('branch . ../branch3')
223
 
        self.run_bzr('commit --unchanged --message peter')
224
 
        os.chdir('../branch2')
225
 
        self.run_bzr('merge ../branch1')
226
 
        self.run_bzr('commit --unchanged --message pumpkin')
227
 
        os.chdir('../branch3')
228
 
        self.run_bzr('merge ../branch2')
229
 
        message = self.run_bzr('status')[0]
 
769
    def test_remerge(self):
 
770
        """Remerge command works as expected"""
 
771
        self.create_conflicts()
 
772
        self.runbzr('merge ../other --show-base', retcode=1)
 
773
        conflict_text = file('hello').read()
 
774
        assert '|||||||' in conflict_text
 
775
        assert 'hi world' in conflict_text
 
776
        self.runbzr('remerge', retcode=1)
 
777
        conflict_text = file('hello').read()
 
778
        assert '|||||||' not in conflict_text
 
779
        assert 'hi world' not in conflict_text
 
780
        os.unlink('hello.OTHER')
 
781
        self.runbzr('remerge hello --merge-type weave', retcode=1)
 
782
        assert os.path.exists('hello.OTHER')
 
783
        file_id = self.runbzr('file-id hello')
 
784
        file_id = self.runbzr('file-id hello.THIS', retcode=3)
 
785
        self.runbzr('remerge --merge-type weave', retcode=1)
 
786
        assert os.path.exists('hello.OTHER')
 
787
        assert not os.path.exists('hello.BASE')
 
788
        assert '|||||||' not in conflict_text
 
789
        assert 'hi world' not in conflict_text
 
790
        self.runbzr('remerge . --merge-type weave --show-base', retcode=3)
 
791
        self.runbzr('remerge . --merge-type weave --reprocess', retcode=3)
 
792
        self.runbzr('remerge . --show-base --reprocess', retcode=3)
 
793
        self.runbzr('remerge hello --show-base', retcode=1)
 
794
        self.runbzr('remerge hello --reprocess', retcode=1)
 
795
        self.runbzr('resolve --all')
 
796
        self.runbzr('commit -m done',)
 
797
        self.runbzr('remerge', retcode=3)
230
798
 
231
799
 
232
800
    def test_conflicts(self):
233
801
        """Handling of merge conflicts"""
234
802
        self.create_conflicts()
235
 
        self.run_bzr('merge ../other --show-base', retcode=1)
 
803
        self.runbzr('merge ../other --show-base', retcode=1)
236
804
        conflict_text = file('hello').read()
237
805
        self.assert_('<<<<<<<' in conflict_text)
238
806
        self.assert_('>>>>>>>' in conflict_text)
239
807
        self.assert_('=======' in conflict_text)
240
808
        self.assert_('|||||||' in conflict_text)
241
809
        self.assert_('hi world' in conflict_text)
242
 
        self.run_bzr('revert')
243
 
        self.run_bzr('resolve --all')
244
 
        self.run_bzr('merge ../other', retcode=1)
 
810
        self.runbzr('revert')
 
811
        self.runbzr('resolve --all')
 
812
        self.runbzr('merge ../other', retcode=1)
245
813
        conflict_text = file('hello').read()
246
814
        self.assert_('|||||||' not in conflict_text)
247
815
        self.assert_('hi world' not in conflict_text)
248
 
        result = self.run_bzr('conflicts')[0]
249
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
250
 
                                  " question\n")
251
 
        result = self.run_bzr('status')[0]
252
 
        self.assert_("conflicts:\n  Text conflict in hello\n"
253
 
                     "  Text conflict in question\n" in result, result)
254
 
        self.run_bzr('resolve hello')
255
 
        result = self.run_bzr('conflicts')[0]
256
 
        self.assertEquals(result, "Text conflict in question\n")
257
 
        self.run_bzr('commit -m conflicts', retcode=3)
258
 
        self.run_bzr('resolve --all')
259
 
        result = self.run_bzr('conflicts')[0]
260
 
        self.run_bzr('commit -m conflicts')
 
816
        result = self.runbzr('conflicts', backtick=1)
 
817
        self.assertEquals(result, "hello\nquestion\n")
 
818
        result = self.runbzr('status', backtick=1)
 
819
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
 
820
        self.runbzr('resolve hello')
 
821
        result = self.runbzr('conflicts', backtick=1)
 
822
        self.assertEquals(result, "question\n")
 
823
        self.runbzr('commit -m conflicts', retcode=3)
 
824
        self.runbzr('resolve --all')
 
825
        result = self.runbzr('conflicts', backtick=1)
 
826
        self.runbzr('commit -m conflicts')
261
827
        self.assertEquals(result, "")
262
828
 
 
829
    def test_resign(self):
 
830
        """Test re signing of data."""
 
831
        import bzrlib.gpg
 
832
        oldstrategy = bzrlib.gpg.GPGStrategy
 
833
        branch = Branch.initialize('.')
 
834
        branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
 
835
        try:
 
836
            # monkey patch gpg signing mechanism
 
837
            from bzrlib.testament import Testament
 
838
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
839
            self.runbzr('re-sign -r revid:A')
 
840
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
841
                             branch.revision_store.get('A', 'sig').read())
 
842
        finally:
 
843
            bzrlib.gpg.GPGStrategy = oldstrategy
 
844
            
 
845
    def test_resign_range(self):
 
846
        import bzrlib.gpg
 
847
        oldstrategy = bzrlib.gpg.GPGStrategy
 
848
        branch = Branch.initialize('.')
 
849
        branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
 
850
        branch.working_tree().commit("base", allow_pointless=True, rev_id='B')
 
851
        branch.working_tree().commit("base", allow_pointless=True, rev_id='C')
 
852
        try:
 
853
            # monkey patch gpg signing mechanism
 
854
            from bzrlib.testament import Testament
 
855
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
856
            self.runbzr('re-sign -r 1..')
 
857
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
858
                             branch.revision_store.get('A', 'sig').read())
 
859
            self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
 
860
                             branch.revision_store.get('B', 'sig').read())
 
861
            self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
 
862
                             branch.revision_store.get('C', 'sig').read())
 
863
        finally:
 
864
            bzrlib.gpg.GPGStrategy = oldstrategy
 
865
 
263
866
    def test_push(self):
264
867
        # create a source branch
265
868
        os.mkdir('my-branch')
267
870
        self.example_branch()
268
871
 
269
872
        # with no push target, fail
270
 
        self.run_bzr('push', retcode=3)
 
873
        self.runbzr('push', retcode=3)
271
874
        # with an explicit target work
272
 
        self.run_bzr('push ../output-branch')
 
875
        self.runbzr('push ../output-branch')
273
876
        # with an implicit target work
274
 
        self.run_bzr('push')
 
877
        self.runbzr('push')
275
878
        # nothing missing
276
 
        self.run_bzr('missing ../output-branch')
 
879
        self.runbzr('missing ../output-branch')
277
880
        # advance this branch
278
 
        self.run_bzr('commit --unchanged -m unchanged')
 
881
        self.runbzr('commit --unchanged -m unchanged')
279
882
 
280
883
        os.chdir('../output-branch')
281
 
        # There is no longer a difference as long as we have
282
 
        # access to the working tree
283
 
        self.run_bzr('diff')
284
 
 
285
 
        # But we should be missing a revision
286
 
        self.run_bzr('missing ../my-branch', retcode=1)
287
 
 
 
884
        # should be a diff as we have not pushed the tree
 
885
        self.runbzr('diff', retcode=1)
 
886
        self.runbzr('revert')
 
887
        # but not now.
 
888
        self.runbzr('diff')
288
889
        # diverge the branches
289
 
        self.run_bzr('commit --unchanged -m unchanged')
 
890
        self.runbzr('commit --unchanged -m unchanged')
290
891
        os.chdir('../my-branch')
291
892
        # cannot push now
292
 
        self.run_bzr('push', retcode=3)
 
893
        self.runbzr('push', retcode=3)
293
894
        # and there are difference
294
 
        self.run_bzr('missing ../output-branch', retcode=1)
295
 
        self.run_bzr('missing --verbose ../output-branch', retcode=1)
 
895
        self.runbzr('missing ../output-branch', retcode=1)
 
896
        self.runbzr('missing --verbose ../output-branch', retcode=1)
296
897
        # but we can force a push
297
 
        self.run_bzr('push --overwrite')
 
898
        self.runbzr('push --overwrite')
298
899
        # nothing missing
299
 
        self.run_bzr('missing ../output-branch')
300
 
 
 
900
        self.runbzr('missing ../output-branch')
 
901
        
301
902
        # pushing to a new dir with no parent should fail
302
 
        self.run_bzr('push ../missing/new-branch', retcode=3)
 
903
        self.runbzr('push ../missing/new-branch', retcode=3)
303
904
        # unless we provide --create-prefix
304
 
        self.run_bzr('push --create-prefix ../missing/new-branch')
 
905
        self.runbzr('push --create-prefix ../missing/new-branch')
305
906
        # nothing missing
306
 
        self.run_bzr('missing ../missing/new-branch')
 
907
        self.runbzr('missing ../missing/new-branch')
307
908
 
308
909
    def test_external_command(self):
309
 
        """Test that external commands can be run by setting the path
310
 
        """
311
 
        # We don't at present run bzr in a subprocess for blackbox tests, and so
312
 
        # don't really capture stdout, only the internal python stream.
313
 
        # Therefore we don't use a subcommand that produces any output or does
314
 
        # anything -- we just check that it can be run successfully.
 
910
        """test that external commands can be run by setting the path"""
315
911
        cmd_name = 'test-command'
 
912
        output = 'Hello from test-command'
316
913
        if sys.platform == 'win32':
317
914
            cmd_name += '.bat'
 
915
            output += '\r\n'
 
916
        else:
 
917
            output += '\n'
 
918
 
318
919
        oldpath = os.environ.get('BZRPATH', None)
 
920
 
 
921
        bzr = self.capture
 
922
 
319
923
        try:
320
 
            if 'BZRPATH' in os.environ:
 
924
            if os.environ.has_key('BZRPATH'):
321
925
                del os.environ['BZRPATH']
322
926
 
323
927
            f = file(cmd_name, 'wb')
325
929
                f.write('@echo off\n')
326
930
            else:
327
931
                f.write('#!/bin/sh\n')
328
 
            # f.write('echo Hello from test-command')
 
932
            f.write('echo Hello from test-command')
329
933
            f.close()
330
934
            os.chmod(cmd_name, 0755)
331
935
 
332
 
            # It should not find the command in the local
 
936
            # It should not find the command in the local 
333
937
            # directory by default, since it is not in my path
334
 
            self.run_bzr(cmd_name, retcode=3)
 
938
            bzr(cmd_name, retcode=3)
335
939
 
336
940
            # Now put it into my path
337
941
            os.environ['BZRPATH'] = '.'
338
942
 
339
 
            self.run_bzr(cmd_name)
 
943
            bzr(cmd_name)
 
944
            # The test suite does not capture stdout for external commands
 
945
            # this is because you have to have a real file object
 
946
            # to pass to Popen(stdout=FOO), and StringIO is not one of those.
 
947
            # (just replacing sys.stdout does not change a spawned objects stdout)
 
948
            #self.assertEquals(bzr(cmd_name), output)
340
949
 
341
950
            # Make sure empty path elements are ignored
342
951
            os.environ['BZRPATH'] = os.pathsep
343
952
 
344
 
            self.run_bzr(cmd_name, retcode=3)
 
953
            bzr(cmd_name, retcode=3)
345
954
 
346
955
        finally:
347
956
            if oldpath:
361
970
        from os import chdir, mkdir
362
971
        from os.path import exists
363
972
 
 
973
        runbzr = self.runbzr
 
974
        capture = self.capture
364
975
        progress = self.log
365
976
 
366
977
        progress("basic branch creation")
367
978
        mkdir('branch1')
368
979
        chdir('branch1')
369
 
        self.run_bzr('init')
 
980
        runbzr('init')
370
981
 
371
 
        self.assertIsSameRealPath(self.run_bzr('root')[0].rstrip(),
372
 
                                  osutils.pathjoin(self.test_dir, 'branch1'))
 
982
        self.assertEquals(capture('root').rstrip(),
 
983
                          os.path.join(self.test_dir, 'branch1'))
373
984
 
374
985
        progress("status of new file")
375
986
 
377
988
        f.write('hello world!\n')
378
989
        f.close()
379
990
 
380
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'test.txt\n')
 
991
        self.assertEquals(capture('unknowns'), 'test.txt\n')
381
992
 
382
 
        out = self.run_bzr("status")[0]
 
993
        out = capture("status")
383
994
        self.assertEquals(out, 'unknown:\n  test.txt\n')
384
995
 
 
996
        out = capture("status --all")
 
997
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
998
 
 
999
        out = capture("status test.txt --all")
 
1000
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
1001
 
385
1002
        f = file('test2.txt', 'wt')
386
1003
        f.write('goodbye cruel world...\n')
387
1004
        f.close()
388
1005
 
389
 
        out = self.run_bzr("status test.txt")[0]
 
1006
        out = capture("status test.txt")
390
1007
        self.assertEquals(out, "unknown:\n  test.txt\n")
391
1008
 
392
 
        out = self.run_bzr("status")[0]
 
1009
        out = capture("status")
393
1010
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
394
1011
 
395
1012
        os.unlink('test2.txt')
396
1013
 
397
1014
        progress("command aliases")
398
 
        out = self.run_bzr("st")[0]
 
1015
        out = capture("st --all")
399
1016
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
400
1017
 
401
 
        out = self.run_bzr("stat")[0]
 
1018
        out = capture("stat")
402
1019
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
403
1020
 
404
1021
        progress("command help")
405
 
        self.run_bzr("help st")
406
 
        self.run_bzr("help")
407
 
        self.run_bzr("help commands")
408
 
        self.run_bzr("help slartibartfast", retcode=3)
409
 
 
410
 
        out = self.run_bzr("help ci")[0]
411
 
        out.index('Aliases:  ci, checkin\n')
 
1022
        runbzr("help st")
 
1023
        runbzr("help")
 
1024
        runbzr("help commands")
 
1025
        runbzr("help slartibartfast", 3)
 
1026
 
 
1027
        out = capture("help ci")
 
1028
        out.index('aliases: ')
 
1029
 
 
1030
        progress("can't rename unversioned file")
 
1031
        runbzr("rename test.txt new-test.txt", 3)
 
1032
 
 
1033
        progress("adding a file")
 
1034
 
 
1035
        runbzr("add test.txt")
 
1036
        self.assertEquals(capture("unknowns"), '')
 
1037
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
 
1038
 
 
1039
        progress("rename newly-added file")
 
1040
        runbzr("rename test.txt hello.txt")
 
1041
        self.assert_(os.path.exists("hello.txt"))
 
1042
        self.assert_(not os.path.exists("test.txt"))
 
1043
 
 
1044
        self.assertEquals(capture("revno"), '0\n')
 
1045
 
 
1046
        progress("add first revision")
 
1047
        runbzr(['commit', '-m', 'add first revision'])
 
1048
 
 
1049
        progress("more complex renames")
 
1050
        os.mkdir("sub1")
 
1051
        runbzr("rename hello.txt sub1", 3)
 
1052
        runbzr("rename hello.txt sub1/hello.txt", 3)
 
1053
        runbzr("move hello.txt sub1", 3)
 
1054
 
 
1055
        runbzr("add sub1")
 
1056
        runbzr("rename sub1 sub2")
 
1057
        runbzr("move hello.txt sub2")
 
1058
        self.assertEqual(capture("relpath sub2/hello.txt"),
 
1059
                         os.path.join("sub2", "hello.txt\n"))
 
1060
 
 
1061
        self.assert_(exists("sub2"))
 
1062
        self.assert_(exists("sub2/hello.txt"))
 
1063
        self.assert_(not exists("sub1"))
 
1064
        self.assert_(not exists("hello.txt"))
 
1065
 
 
1066
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
1067
 
 
1068
        mkdir("sub1")
 
1069
        runbzr('add sub1')
 
1070
        runbzr('move sub2/hello.txt sub1')
 
1071
        self.assert_(not exists('sub2/hello.txt'))
 
1072
        self.assert_(exists('sub1/hello.txt'))
 
1073
        runbzr('move sub2 sub1')
 
1074
        self.assert_(not exists('sub2'))
 
1075
        self.assert_(exists('sub1/sub2'))
 
1076
 
 
1077
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
1078
 
 
1079
        chdir('sub1/sub2')
 
1080
        self.assertEquals(capture('root')[:-1],
 
1081
                          os.path.join(self.test_dir, 'branch1'))
 
1082
        runbzr('move ../hello.txt .')
 
1083
        self.assert_(exists('./hello.txt'))
 
1084
        self.assertEquals(capture('relpath hello.txt'),
 
1085
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
1086
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
 
1087
        runbzr(['commit', '-m', 'move to parent directory'])
 
1088
        chdir('..')
 
1089
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
 
1090
 
 
1091
        runbzr('move sub2/hello.txt .')
 
1092
        self.assert_(exists('hello.txt'))
412
1093
 
413
1094
        f = file('hello.txt', 'wt')
414
1095
        f.write('some nice new content\n')
415
1096
        f.close()
416
1097
 
417
 
        self.run_bzr("add hello.txt")
418
 
 
419
1098
        f = file('msg.tmp', 'wt')
420
1099
        f.write('this is my new commit\nand it has multiple lines, for fun')
421
1100
        f.close()
422
1101
 
423
 
        self.run_bzr('commit -F msg.tmp')
424
 
 
425
 
        self.assertEquals(self.run_bzr('revno')[0], '1\n')
426
 
        self.run_bzr('export -r 1 export-1.tmp')
427
 
        self.run_bzr('export export.tmp')
428
 
 
429
 
        self.run_bzr('log')
430
 
        self.run_bzr('log -v')
431
 
        self.run_bzr('log -v --forward')
432
 
        self.run_bzr('log -m', retcode=3)
433
 
        log_out = self.run_bzr('log -m commit')[0]
 
1102
        runbzr('commit -F msg.tmp')
 
1103
 
 
1104
        self.assertEquals(capture('revno'), '5\n')
 
1105
        runbzr('export -r 5 export-5.tmp')
 
1106
        runbzr('export export.tmp')
 
1107
 
 
1108
        runbzr('log')
 
1109
        runbzr('log -v')
 
1110
        runbzr('log -v --forward')
 
1111
        runbzr('log -m', retcode=3)
 
1112
        log_out = capture('log -m commit')
434
1113
        self.assert_("this is my new commit\n  and" in log_out)
435
1114
        self.assert_("rename nested" not in log_out)
436
1115
        self.assert_('revision-id' not in log_out)
437
 
        self.assert_('revision-id' in self.run_bzr('log --show-ids -m commit')[0])
438
 
 
439
 
        log_out = self.run_bzr('log --line')[0]
440
 
        # determine the widest line we want
441
 
        max_width = osutils.terminal_width()
442
 
        if max_width is not None:
443
 
            for line in log_out.splitlines():
444
 
                self.assert_(len(line) <= max_width - 1, len(line))
445
 
        self.assert_("this is my new commit and" not in log_out)
446
 
        self.assert_("this is my new commit" in log_out)
 
1116
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
1117
 
 
1118
        log_out = capture('log --line')
 
1119
        for line in log_out.splitlines():
 
1120
            self.assert_(len(line) <= 79, len(line))
 
1121
        self.assert_("this is my new commit and" in log_out)
 
1122
 
447
1123
 
448
1124
        progress("file with spaces in name")
449
1125
        mkdir('sub directory')
450
1126
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
451
 
        self.run_bzr('add .')
452
 
        self.run_bzr('diff', retcode=1)
453
 
        self.run_bzr('commit -m add-spaces')
454
 
        self.run_bzr('check')
455
 
 
456
 
        self.run_bzr('log')
457
 
        self.run_bzr('log --forward')
458
 
 
459
 
        self.run_bzr('info')
460
 
 
461
 
        if osutils.has_symlinks():
 
1127
        runbzr('add .')
 
1128
        runbzr('diff', retcode=1)
 
1129
        runbzr('commit -m add-spaces')
 
1130
        runbzr('check')
 
1131
 
 
1132
        runbzr('log')
 
1133
        runbzr('log --forward')
 
1134
 
 
1135
        runbzr('info')
 
1136
 
 
1137
        if has_symlinks():
462
1138
            progress("symlinks")
463
1139
            mkdir('symlinks')
464
1140
            chdir('symlinks')
465
 
            self.run_bzr('init')
 
1141
            runbzr('init')
466
1142
            os.symlink("NOWHERE1", "link1")
467
 
            self.run_bzr('add link1')
468
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
469
 
            self.run_bzr(['commit', '-m', '1: added symlink link1'])
470
 
 
 
1143
            runbzr('add link1')
 
1144
            self.assertEquals(self.capture('unknowns'), '')
 
1145
            runbzr(['commit', '-m', '1: added symlink link1'])
 
1146
    
471
1147
            mkdir('d1')
472
 
            self.run_bzr('add d1')
473
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
 
1148
            runbzr('add d1')
 
1149
            self.assertEquals(self.capture('unknowns'), '')
474
1150
            os.symlink("NOWHERE2", "d1/link2")
475
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd1/link2\n')
 
1151
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
476
1152
            # is d1/link2 found when adding d1
477
 
            self.run_bzr('add d1')
478
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
 
1153
            runbzr('add d1')
 
1154
            self.assertEquals(self.capture('unknowns'), '')
479
1155
            os.symlink("NOWHERE3", "d1/link3")
480
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd1/link3\n')
481
 
            self.run_bzr(['commit', '-m', '2: added dir, symlink'])
482
 
 
483
 
            self.run_bzr('rename d1 d2')
484
 
            self.run_bzr('move d2/link2 .')
485
 
            self.run_bzr('move link1 d2')
 
1156
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
1157
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
1158
    
 
1159
            runbzr('rename d1 d2')
 
1160
            runbzr('move d2/link2 .')
 
1161
            runbzr('move link1 d2')
486
1162
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
487
1163
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
488
 
            self.run_bzr('add d2/link3')
489
 
            self.run_bzr('diff', retcode=1)
490
 
            self.run_bzr(['commit', '-m',
491
 
                          '3: rename of dir, move symlinks, add link3'])
492
 
 
 
1164
            runbzr('add d2/link3')
 
1165
            runbzr('diff', retcode=1)
 
1166
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
1167
    
493
1168
            os.unlink("link2")
494
1169
            os.symlink("TARGET 2", "link2")
495
1170
            os.unlink("d2/link1")
496
1171
            os.symlink("TARGET 1", "d2/link1")
497
 
            self.run_bzr('diff', retcode=1)
498
 
            self.assertEquals(self.run_bzr("relpath d2/link1")[0], "d2/link1\n")
499
 
            self.run_bzr(['commit', '-m', '4: retarget of two links'])
500
 
 
501
 
            self.run_bzr('remove --keep d2/link1')
502
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd2/link1\n')
503
 
            self.run_bzr(['commit', '-m', '5: remove d2/link1'])
 
1172
            runbzr('diff', retcode=1)
 
1173
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
1174
            runbzr(['commit', '-m', '4: retarget of two links'])
 
1175
    
 
1176
            runbzr('remove d2/link1')
 
1177
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1178
            runbzr(['commit', '-m', '5: remove d2/link1'])
504
1179
            # try with the rm alias
505
 
            self.run_bzr('add d2/link1')
506
 
            self.run_bzr(['commit', '-m', '6: add d2/link1'])
507
 
            self.run_bzr('rm --keep d2/link1')
508
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd2/link1\n')
509
 
            self.run_bzr(['commit', '-m', '7: remove d2/link1'])
510
 
 
 
1180
            runbzr('add d2/link1')
 
1181
            runbzr(['commit', '-m', '6: add d2/link1'])
 
1182
            runbzr('rm d2/link1')
 
1183
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1184
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
1185
    
511
1186
            os.mkdir("d1")
512
 
            self.run_bzr('add d1')
513
 
            self.run_bzr('rename d2/link3 d1/link3new')
514
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd2/link1\n')
515
 
            self.run_bzr(['commit', '-m',
516
 
                          '8: remove d2/link1, move/rename link3'])
517
 
 
518
 
            self.run_bzr('check')
519
 
 
520
 
            self.run_bzr('export -r 1 exp1.tmp')
 
1187
            runbzr('add d1')
 
1188
            runbzr('rename d2/link3 d1/link3new')
 
1189
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1190
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
1191
            
 
1192
            runbzr(['check'])
 
1193
            
 
1194
            runbzr(['export', '-r', '1', 'exp1.tmp'])
521
1195
            chdir("exp1.tmp")
522
1196
            self.assertEquals(listdir_sorted("."), [ "link1" ])
523
1197
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
524
1198
            chdir("..")
525
 
 
526
 
            self.run_bzr('export -r 2 exp2.tmp')
 
1199
            
 
1200
            runbzr(['export', '-r', '2', 'exp2.tmp'])
527
1201
            chdir("exp2.tmp")
528
1202
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
529
1203
            chdir("..")
530
 
 
531
 
            self.run_bzr('export -r 3 exp3.tmp')
 
1204
            
 
1205
            runbzr(['export', '-r', '3', 'exp3.tmp'])
532
1206
            chdir("exp3.tmp")
533
1207
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
534
1208
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
535
1209
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
536
1210
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
537
1211
            chdir("..")
538
 
 
539
 
            self.run_bzr('export -r 4 exp4.tmp')
 
1212
            
 
1213
            runbzr(['export', '-r', '4', 'exp4.tmp'])
540
1214
            chdir("exp4.tmp")
541
1215
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
542
1216
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
543
1217
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
544
1218
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
545
1219
            chdir("..")
546
 
 
547
 
            self.run_bzr('export -r 5 exp5.tmp')
 
1220
            
 
1221
            runbzr(['export', '-r', '5', 'exp5.tmp'])
548
1222
            chdir("exp5.tmp")
549
1223
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
550
1224
            self.assert_(os.path.islink("link2"))
551
1225
            self.assert_(listdir_sorted("d2")== [ "link3" ])
552
1226
            chdir("..")
553
 
 
554
 
            self.run_bzr('export -r 8 exp6.tmp')
 
1227
            
 
1228
            runbzr(['export', '-r', '8', 'exp6.tmp'])
555
1229
            chdir("exp6.tmp")
556
1230
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
557
1231
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
562
1236
            progress("skipping symlink tests")
563
1237
 
564
1238
 
565
 
class RemoteTests(object):
 
1239
class HttpTests(TestCaseWithWebserver):
566
1240
    """Test bzr ui commands against remote branches."""
567
1241
 
568
1242
    def test_branch(self):
569
1243
        os.mkdir('from')
570
 
        wt = self.make_branch_and_tree('from')
571
 
        branch = wt.branch
572
 
        wt.commit('empty commit for nonsense', allow_pointless=True)
573
 
        url = self.get_readonly_url('from')
574
 
        self.run_bzr(['branch', url, 'to'])
 
1244
        branch = Branch.initialize('from')
 
1245
        branch.working_tree().commit('empty commit for nonsense', allow_pointless=True)
 
1246
        url = self.get_remote_url('from')
 
1247
        self.run_bzr('branch', url, 'to')
575
1248
        branch = Branch.open('to')
576
1249
        self.assertEqual(1, len(branch.revision_history()))
577
 
        # the branch should be set in to to from
578
 
        self.assertEqual(url + '/', branch.get_parent())
579
1250
 
580
1251
    def test_log(self):
581
1252
        self.build_tree(['branch/', 'branch/file'])
582
 
        self.run_bzr('init branch')[0]
583
 
        self.run_bzr('add branch/file')[0]
584
 
        self.run_bzr('commit -m foo branch')[0]
585
 
        url = self.get_readonly_url('branch/file')
586
 
        output = self.run_bzr('log %s' % url)[0]
 
1253
        branch = Branch.initialize('branch')
 
1254
        branch.add(['file'])
 
1255
        branch.working_tree().commit('add file', rev_id='A')
 
1256
        url = self.get_remote_url('branch/file')
 
1257
        output = self.capture('log %s' % url)
587
1258
        self.assertEqual(8, len(output.split('\n')))
588
 
 
589
 
    def test_check(self):
590
 
        self.build_tree(['branch/', 'branch/file'])
591
 
        self.run_bzr('init branch')[0]
592
 
        self.run_bzr('add branch/file')[0]
593
 
        self.run_bzr('commit -m foo branch')[0]
594
 
        url = self.get_readonly_url('branch/')
595
 
        self.run_bzr(['check', url])
596
 
 
597
 
    def test_push(self):
598
 
        # create a source branch
599
 
        os.mkdir('my-branch')
600
 
        os.chdir('my-branch')
601
 
        self.run_bzr('init')
602
 
        file('hello', 'wt').write('foo')
603
 
        self.run_bzr('add hello')
604
 
        self.run_bzr('commit -m setup')
605
 
 
606
 
        # with an explicit target work
607
 
        self.run_bzr(['push', self.get_url('output-branch')])
608
 
 
609
 
 
610
 
class HTTPTests(TestCaseWithWebserver, RemoteTests):
611
 
    """Test various commands against a HTTP server."""
612
 
 
613
 
 
614
 
class SFTPTestsAbsolute(TestCaseWithSFTPServer, RemoteTests):
615
 
    """Test various commands against a SFTP server using abs paths."""
616
 
 
617
 
 
618
 
class SFTPTestsAbsoluteSibling(TestCaseWithSFTPServer, RemoteTests):
619
 
    """Test various commands against a SFTP server using abs paths."""
620
 
 
621
 
    def setUp(self):
622
 
        super(SFTPTestsAbsoluteSibling, self).setUp()
623
 
        self._override_home = '/dev/noone/runs/tests/here'
624
 
 
625
 
 
626
 
class SFTPTestsRelative(TestCaseWithSFTPServer, RemoteTests):
627
 
    """Test various commands against a SFTP server using homedir rel paths."""
628
 
 
629
 
    def setUp(self):
630
 
        super(SFTPTestsRelative, self).setUp()
631
 
        self._get_remote_is_absolute = False
 
1259
        
 
1260
 
 
1261
 
 
1262