/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

  • Committer: Jelmer Vernooij
  • Date: 2005-10-02 13:14:12 UTC
  • mto: This revision was merged to the branch mainline in revision 1414.
  • Revision ID: jelmer@samba.org-20051002131412-c44d6cd10336ac94
Add test for empty commit messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
26
 
rather starts again from the run_bzr function.
 
22
command-line interface.
 
23
 
 
24
This always reinvokes bzr through a new Python interpreter, which is a
 
25
bit inefficient but arguably tests in a way more representative of how
 
26
it's normally invoked.
27
27
"""
28
28
 
29
 
 
30
 
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
31
 
# 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.
34
 
 
35
 
 
36
29
from cStringIO import StringIO
37
30
import os
38
 
import re
 
31
import shutil
39
32
import sys
40
33
 
41
 
import bzrlib
42
 
from bzrlib import (
43
 
    osutils,
44
 
    )
 
34
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
45
35
from bzrlib.branch import Branch
46
36
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
 
37
 
 
38
 
 
39
class ExternalBase(TestCaseInTempDir):
 
40
 
 
41
    def runbzr(self, args, retcode=0, backtick=False):
 
42
        if isinstance(args, basestring):
 
43
            args = args.split()
 
44
 
 
45
        if backtick:
 
46
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
47
        else:
 
48
            return self.run_bzr_captured(args, retcode=retcode)
51
49
 
52
50
 
53
51
class TestCommands(ExternalBase):
54
52
 
 
53
    def test_help_commands(self):
 
54
        self.runbzr('--help')
 
55
        self.runbzr('help')
 
56
        self.runbzr('help commands')
 
57
        self.runbzr('help help')
 
58
        self.runbzr('commit -h')
 
59
 
 
60
    def test_init_branch(self):
 
61
        self.runbzr(['init'])
 
62
 
 
63
    def test_whoami(self):
 
64
        # this should always identify something, if only "john@localhost"
 
65
        self.runbzr("whoami")
 
66
        self.runbzr("whoami --email")
 
67
 
 
68
        self.assertEquals(self.runbzr("whoami --email",
 
69
                                      backtick=True).count('@'), 1)
 
70
        
 
71
    def test_whoami_branch(self):
 
72
        """branch specific user identity works."""
 
73
        self.runbzr('init')
 
74
        f = file('.bzr/email', 'wt')
 
75
        f.write('Branch Identity <branch@identi.ty>')
 
76
        f.close()
 
77
        bzr_email = os.environ.get('BZREMAIL')
 
78
        if bzr_email is not None:
 
79
            del os.environ['BZREMAIL']
 
80
        whoami = self.runbzr("whoami",backtick=True)
 
81
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
82
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
83
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
84
        # Verify that the environment variable overrides the value 
 
85
        # in the file
 
86
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
87
        whoami = self.runbzr("whoami",backtick=True)
 
88
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
89
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
90
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
91
        if bzr_email is not None:
 
92
            os.environ['BZREMAIL'] = bzr_email
 
93
 
55
94
    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)
 
95
        self.runbzr("pants", retcode=1)
 
96
        self.runbzr("--pants off", retcode=1)
 
97
        self.runbzr("diff --message foo", retcode=1)
 
98
 
 
99
    def test_empty_commit(self):
 
100
        self.runbzr("init")
 
101
        self.build_tree(['hello.txt'])
 
102
        self.runbzr("commit -m empty", retcode=1)
 
103
        self.runbzr("add hello.txt")
 
104
        self.runbzr("commit -m added")
 
105
 
 
106
    def test_empty_commit_message(self):
 
107
        os.environ['BZR_EDITOR'] = 'touch' 
 
108
        self.runbzr("init")
 
109
        file('foo.c', 'wt').write('int main() {}')
 
110
        self.runbzr(['add', 'foo.c'])
 
111
        self.runbzr("commit", 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'
59
144
 
60
145
    def test_revert(self):
61
 
        self.run_bzr('init')
 
146
        self.runbzr('init')
62
147
 
63
148
        file('hello', 'wt').write('foo')
64
 
        self.run_bzr('add hello')
65
 
        self.run_bzr('commit -m setup hello')
 
149
        self.runbzr('add hello')
 
150
        self.runbzr('commit -m setup hello')
66
151
 
67
152
        file('goodbye', 'wt').write('baz')
68
 
        self.run_bzr('add goodbye')
69
 
        self.run_bzr('commit -m setup goodbye')
70
 
 
 
153
        self.runbzr('add goodbye')
 
154
        self.runbzr('commit -m setup goodbye')
 
155
        
71
156
        file('hello', 'wt').write('bar')
72
157
        file('goodbye', 'wt').write('qux')
73
 
        self.run_bzr('revert hello')
 
158
        self.runbzr('revert hello')
74
159
        self.check_file_contents('hello', 'foo')
75
160
        self.check_file_contents('goodbye', 'qux')
76
 
        self.run_bzr('revert')
 
161
        self.runbzr('revert')
77
162
        self.check_file_contents('goodbye', 'baz')
78
163
 
79
164
        os.mkdir('revertdir')
80
 
        self.run_bzr('add revertdir')
81
 
        self.run_bzr('commit -m f')
 
165
        self.runbzr('add revertdir')
 
166
        self.runbzr('commit -m f')
82
167
        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")
 
168
        self.runbzr('revert')
99
169
 
100
170
        file('hello', 'wt').write('xyz')
101
 
        self.run_bzr('commit -m xyz hello')
102
 
        self.run_bzr('revert -r 1 hello')
 
171
        self.runbzr('commit -m xyz hello')
 
172
        self.runbzr('revert -r 1 hello')
103
173
        self.check_file_contents('hello', 'foo')
104
 
        self.run_bzr('revert hello')
 
174
        self.runbzr('revert hello')
105
175
        self.check_file_contents('hello', 'xyz')
106
176
        os.chdir('revertdir')
107
 
        self.run_bzr('revert')
 
177
        self.runbzr('revert')
108
178
        os.chdir('..')
109
179
 
 
180
 
 
181
    def test_mv_modes(self):
 
182
        """Test two modes of operation for mv"""
 
183
        from bzrlib.branch import Branch
 
184
        b = Branch.initialize('.')
 
185
        self.build_tree(['a', 'c', 'subdir/'])
 
186
        self.run_bzr_captured(['add', self.test_dir])
 
187
        self.run_bzr_captured(['mv', 'a', 'b'])
 
188
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
189
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
190
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
191
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
192
 
 
193
 
 
194
    def test_main_version(self):
 
195
        """Check output from version command and master option is reasonable"""
 
196
        # output is intentionally passed through to stdout so that we
 
197
        # can see the version being tested
 
198
        output = self.runbzr('version', backtick=1)
 
199
        self.log('bzr version output:')
 
200
        self.log(output)
 
201
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
202
        self.assertNotEqual(output.index('Canonical'), -1)
 
203
        # make sure --version is consistent
 
204
        tmp_output = self.runbzr('--version', backtick=1)
 
205
        self.log('bzr --version output:')
 
206
        self.log(tmp_output)
 
207
        self.assertEquals(output, tmp_output)
 
208
 
110
209
    def example_branch(test):
111
 
        test.run_bzr('init')
 
210
        test.runbzr('init')
112
211
        file('hello', 'wt').write('foo')
113
 
        test.run_bzr('add hello')
114
 
        test.run_bzr('commit -m setup hello')
 
212
        test.runbzr('add hello')
 
213
        test.runbzr('commit -m setup hello')
115
214
        file('goodbye', 'wt').write('baz')
116
 
        test.run_bzr('add goodbye')
117
 
        test.run_bzr('commit -m setup goodbye')
118
 
 
119
 
    def test_pull_verbose(self):
120
 
        """Pull changes from one branch to another and watch the output."""
121
 
 
122
 
        os.mkdir('a')
123
 
        os.chdir('a')
124
 
 
125
 
        self.example_branch()
126
 
 
127
 
        os.chdir('..')
128
 
        self.run_bzr('branch a b')
129
 
        os.chdir('b')
130
 
        open('b', 'wb').write('else\n')
131
 
        self.run_bzr('add b')
132
 
        self.run_bzr(['commit', '-m', 'added b'])
133
 
 
134
 
        os.chdir('../a')
135
 
        out = self.run_bzr('pull --verbose ../b')[0]
136
 
        self.failIfEqual(out.find('Added Revisions:'), -1)
137
 
        self.failIfEqual(out.find('message:\n  added b'), -1)
138
 
        self.failIfEqual(out.find('added b'), -1)
139
 
 
140
 
        # Check that --overwrite --verbose prints out the removed entries
141
 
        self.run_bzr('commit -m foo --unchanged')
142
 
        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]
146
 
 
147
 
        remove_loc = out.find('Removed Revisions:')
148
 
        self.failIfEqual(remove_loc, -1)
149
 
        added_loc = out.find('Added Revisions:')
150
 
        self.failIfEqual(added_loc, -1)
151
 
 
152
 
        removed_message = out.find('message:\n  baz')
153
 
        self.failIfEqual(removed_message, -1)
154
 
        self.failUnless(remove_loc < removed_message < added_loc)
155
 
 
156
 
        added_message = out.find('message:\n  foo')
157
 
        self.failIfEqual(added_message, -1)
158
 
        self.failUnless(added_loc < added_message)
159
 
 
160
 
    def test_locations(self):
161
 
        """Using and remembering different locations"""
162
 
        os.mkdir('a')
163
 
        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')
169
 
        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')
174
 
        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')
181
 
        os.chdir('../b')
182
 
        self.run_bzr('pull')
183
 
        os.chdir('../d')
184
 
        self.run_bzr('pull', retcode=3)
185
 
        self.run_bzr('pull ../a --remember')
186
 
        self.run_bzr('pull')
 
215
        test.runbzr('add goodbye')
 
216
        test.runbzr('commit -m setup goodbye')
 
217
 
 
218
    def test_export(self):
 
219
        os.mkdir('branch')
 
220
        os.chdir('branch')
 
221
        self.example_branch()
 
222
        self.runbzr('export ../latest')
 
223
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
224
        self.runbzr('export ../first -r 1')
 
225
        assert not os.path.exists('../first/goodbye')
 
226
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
227
        self.runbzr('export ../first.gz -r 1')
 
228
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
229
        self.runbzr('export ../first.bz2 -r 1')
 
230
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
231
        self.runbzr('export ../first.tar -r 1')
 
232
        assert os.path.isfile('../first.tar')
 
233
        from tarfile import TarFile
 
234
        tf = TarFile('../first.tar')
 
235
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
236
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
237
        self.runbzr('export ../first.tar.gz -r 1')
 
238
        assert os.path.isfile('../first.tar.gz')
 
239
        self.runbzr('export ../first.tbz2 -r 1')
 
240
        assert os.path.isfile('../first.tbz2')
 
241
        self.runbzr('export ../first.tar.bz2 -r 1')
 
242
        assert os.path.isfile('../first.tar.bz2')
 
243
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
244
        assert os.path.isfile('../first.tar.tbz2')
 
245
        from bz2 import BZ2File
 
246
        tf = TarFile('../first.tar.tbz2', 
 
247
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
248
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
249
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
250
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
251
        tf = TarFile('../first2.tar')
 
252
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
253
 
 
254
    def test_diff(self):
 
255
        self.example_branch()
 
256
        file('hello', 'wt').write('hello world!')
 
257
        self.runbzr('commit -m fixing hello')
 
258
        output = self.runbzr('diff -r 2..3', backtick=1)
 
259
        self.assert_('\n+hello world!' in output)
 
260
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
261
        self.assert_('\n+baz' in output)
 
262
 
 
263
    def test_branch(self):
 
264
        """Branch from one branch to another."""
 
265
        os.mkdir('a')
 
266
        os.chdir('a')
 
267
        self.example_branch()
 
268
        os.chdir('..')
 
269
        self.runbzr('branch a b')
 
270
        self.runbzr('branch a c -r 1')
 
271
        os.chdir('b')
 
272
        self.runbzr('commit -m foo --unchanged')
 
273
        os.chdir('..')
 
274
        # naughty - abstraction violations RBC 20050928  
 
275
        print "test_branch used to delete the stores, how is this meant to work ?"
 
276
        #shutil.rmtree('a/.bzr/revision-store')
 
277
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
278
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
279
        self.runbzr('branch a d --basis b')
 
280
 
 
281
    def test_merge(self):
 
282
        from bzrlib.branch import Branch
 
283
        
 
284
        os.mkdir('a')
 
285
        os.chdir('a')
 
286
        self.example_branch()
 
287
        os.chdir('..')
 
288
        self.runbzr('branch a b')
 
289
        os.chdir('b')
 
290
        file('goodbye', 'wt').write('quux')
 
291
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
292
 
 
293
        os.chdir('../a')
 
294
        file('hello', 'wt').write('quuux')
 
295
        # We can't merge when there are in-tree changes
 
296
        self.runbzr('merge ../b', retcode=1)
 
297
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
298
        self.runbzr('merge ../b')
 
299
        self.check_file_contents('goodbye', 'quux')
 
300
        # Merging a branch pulls its revision into the tree
 
301
        a = Branch.open('.')
 
302
        b = Branch.open('../b')
 
303
        a.get_revision_xml(b.last_revision())
 
304
        self.log('pending merges: %s', a.pending_merges())
 
305
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
306
        #        % (a.pending_merges(), b.last_revision())
 
307
 
 
308
    def test_merge_with_missing_file(self):
 
309
        """Merge handles missing file conflicts"""
 
310
        os.mkdir('a')
 
311
        os.chdir('a')
 
312
        os.mkdir('sub')
 
313
        print >> file('sub/a.txt', 'wb'), "hello"
 
314
        print >> file('b.txt', 'wb'), "hello"
 
315
        print >> file('sub/c.txt', 'wb'), "hello"
 
316
        self.runbzr('init')
 
317
        self.runbzr('add')
 
318
        self.runbzr(('commit', '-m', 'added a'))
 
319
        self.runbzr('branch . ../b')
 
320
        print >> file('sub/a.txt', 'ab'), "there"
 
321
        print >> file('b.txt', 'ab'), "there"
 
322
        print >> file('sub/c.txt', 'ab'), "there"
 
323
        self.runbzr(('commit', '-m', 'Added there'))
 
324
        os.unlink('sub/a.txt')
 
325
        os.unlink('sub/c.txt')
 
326
        os.rmdir('sub')
 
327
        os.unlink('b.txt')
 
328
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
329
        os.chdir('../b')
 
330
        print >> file('sub/a.txt', 'ab'), "something"
 
331
        print >> file('b.txt', 'ab'), "something"
 
332
        print >> file('sub/c.txt', 'ab'), "something"
 
333
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
334
        self.runbzr('merge ../a/')
 
335
        assert os.path.exists('sub/a.txt.THIS')
 
336
        assert os.path.exists('sub/a.txt.BASE')
 
337
        os.chdir('../a')
 
338
        self.runbzr('merge ../b/')
 
339
        assert os.path.exists('sub/a.txt.OTHER')
 
340
        assert os.path.exists('sub/a.txt.BASE')
 
341
 
 
342
    def test_pull(self):
 
343
        """Pull changes from one branch to another."""
 
344
        os.mkdir('a')
 
345
        os.chdir('a')
 
346
 
 
347
        self.example_branch()
 
348
        self.runbzr('pull', retcode=1)
 
349
        self.runbzr('missing', retcode=1)
 
350
        self.runbzr('missing .')
 
351
        self.runbzr('missing')
 
352
        self.runbzr('pull')
 
353
        self.runbzr('pull /', retcode=1)
 
354
        self.runbzr('pull')
 
355
 
 
356
        os.chdir('..')
 
357
        self.runbzr('branch a b')
 
358
        os.chdir('b')
 
359
        self.runbzr('pull')
 
360
        os.mkdir('subdir')
 
361
        self.runbzr('add subdir')
 
362
        self.runbzr('commit -m blah --unchanged')
 
363
        os.chdir('../a')
 
364
        a = Branch.open('.')
 
365
        b = Branch.open('../b')
 
366
        assert a.revision_history() == b.revision_history()[:-1]
 
367
        self.runbzr('pull ../b')
 
368
        assert a.revision_history() == b.revision_history()
 
369
        self.runbzr('commit -m blah2 --unchanged')
 
370
        os.chdir('../b')
 
371
        self.runbzr('commit -m blah3 --unchanged')
 
372
        self.runbzr('pull ../a', retcode=1)
 
373
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
374
        return
 
375
        os.chdir('../a')
 
376
        self.runbzr('merge ../b')
 
377
        self.runbzr('commit -m blah4 --unchanged')
 
378
        os.chdir('../b/subdir')
 
379
        self.runbzr('pull ../../a')
 
380
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
381
        self.runbzr('commit -m blah5 --unchanged')
 
382
        self.runbzr('commit -m blah6 --unchanged')
 
383
        os.chdir('..')
 
384
        self.runbzr('pull ../a')
 
385
        os.chdir('../a')
 
386
        self.runbzr('commit -m blah7 --unchanged')
 
387
        self.runbzr('merge ../b')
 
388
        self.runbzr('commit -m blah8 --unchanged')
 
389
        self.runbzr('pull ../b')
 
390
        self.runbzr('pull ../b')
 
391
        
 
392
    def test_add_reports(self):
 
393
        """add command prints the names of added files."""
 
394
        b = Branch.initialize('.')
 
395
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
396
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
397
        # the ordering is not defined at the moment
 
398
        results = sorted(out.rstrip('\n').split('\n'))
 
399
        self.assertEquals(['added dir',
 
400
                           'added dir'+os.sep+'sub.txt',
 
401
                           'added top.txt',],
 
402
                          results)
187
403
 
188
404
    def test_unknown_command(self):
189
405
        """Handling of unknown command."""
190
 
        out, err = self.run_bzr('fluffy-badger', retcode=3)
 
406
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
407
                                         retcode=1)
191
408
        self.assertEquals(out, '')
192
409
        err.index('unknown command')
193
 
 
194
 
    def create_conflicts(self):
195
 
        """Create a conflicted tree"""
196
 
        os.mkdir('base')
197
 
        os.chdir('base')
198
 
        file('hello', 'wb').write("hi world")
199
 
        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')
205
 
        os.chdir('../other')
206
 
        file('hello', 'wb').write("Hello.")
207
 
        file('answer', 'wb').write("Is anyone there?")
208
 
        self.run_bzr('commit -m other')
209
 
        os.chdir('../this')
210
 
        file('hello', 'wb').write("Hello, world")
211
 
        self.run_bzr('mv answer question')
212
 
        file('question', 'wb').write("What do you get when you multiply six"
213
 
                                   "times nine?")
214
 
        self.run_bzr('commit -m this')
215
 
 
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]
230
 
 
231
 
 
232
 
    def test_conflicts(self):
233
 
        """Handling of merge conflicts"""
234
 
        self.create_conflicts()
235
 
        self.run_bzr('merge ../other --show-base', retcode=1)
236
 
        conflict_text = file('hello').read()
237
 
        self.assert_('<<<<<<<' in conflict_text)
238
 
        self.assert_('>>>>>>>' in conflict_text)
239
 
        self.assert_('=======' in conflict_text)
240
 
        self.assert_('|||||||' in conflict_text)
241
 
        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)
245
 
        conflict_text = file('hello').read()
246
 
        self.assert_('|||||||' not in conflict_text)
247
 
        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')
261
 
        self.assertEquals(result, "")
262
 
 
263
 
    def test_push(self):
264
 
        # create a source branch
265
 
        os.mkdir('my-branch')
266
 
        os.chdir('my-branch')
267
 
        self.example_branch()
268
 
 
269
 
        # with no push target, fail
270
 
        self.run_bzr('push', retcode=3)
271
 
        # with an explicit target work
272
 
        self.run_bzr('push ../output-branch')
273
 
        # with an implicit target work
274
 
        self.run_bzr('push')
275
 
        # nothing missing
276
 
        self.run_bzr('missing ../output-branch')
277
 
        # advance this branch
278
 
        self.run_bzr('commit --unchanged -m unchanged')
279
 
 
280
 
        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
 
 
288
 
        # diverge the branches
289
 
        self.run_bzr('commit --unchanged -m unchanged')
290
 
        os.chdir('../my-branch')
291
 
        # cannot push now
292
 
        self.run_bzr('push', retcode=3)
293
 
        # and there are difference
294
 
        self.run_bzr('missing ../output-branch', retcode=1)
295
 
        self.run_bzr('missing --verbose ../output-branch', retcode=1)
296
 
        # but we can force a push
297
 
        self.run_bzr('push --overwrite')
298
 
        # nothing missing
299
 
        self.run_bzr('missing ../output-branch')
300
 
 
301
 
        # pushing to a new dir with no parent should fail
302
 
        self.run_bzr('push ../missing/new-branch', retcode=3)
303
 
        # unless we provide --create-prefix
304
 
        self.run_bzr('push --create-prefix ../missing/new-branch')
305
 
        # nothing missing
306
 
        self.run_bzr('missing ../missing/new-branch')
307
 
 
308
 
    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.
315
 
        cmd_name = 'test-command'
316
 
        if sys.platform == 'win32':
317
 
            cmd_name += '.bat'
318
 
        oldpath = os.environ.get('BZRPATH', None)
319
 
        try:
320
 
            if 'BZRPATH' in os.environ:
321
 
                del os.environ['BZRPATH']
322
 
 
323
 
            f = file(cmd_name, 'wb')
324
 
            if sys.platform == 'win32':
325
 
                f.write('@echo off\n')
326
 
            else:
327
 
                f.write('#!/bin/sh\n')
328
 
            # f.write('echo Hello from test-command')
329
 
            f.close()
330
 
            os.chmod(cmd_name, 0755)
331
 
 
332
 
            # It should not find the command in the local
333
 
            # directory by default, since it is not in my path
334
 
            self.run_bzr(cmd_name, retcode=3)
335
 
 
336
 
            # Now put it into my path
337
 
            os.environ['BZRPATH'] = '.'
338
 
 
339
 
            self.run_bzr(cmd_name)
340
 
 
341
 
            # Make sure empty path elements are ignored
342
 
            os.environ['BZRPATH'] = os.pathsep
343
 
 
344
 
            self.run_bzr(cmd_name, retcode=3)
345
 
 
346
 
        finally:
347
 
            if oldpath:
348
 
                os.environ['BZRPATH'] = oldpath
349
 
 
350
 
 
351
 
def listdir_sorted(dir):
352
 
    L = os.listdir(dir)
353
 
    L.sort()
354
 
    return L
 
410
        
355
411
 
356
412
 
357
413
class OldTests(ExternalBase):
361
417
        from os import chdir, mkdir
362
418
        from os.path import exists
363
419
 
 
420
        runbzr = self.runbzr
 
421
        capture = self.capture
364
422
        progress = self.log
365
423
 
366
424
        progress("basic branch creation")
367
425
        mkdir('branch1')
368
426
        chdir('branch1')
369
 
        self.run_bzr('init')
 
427
        runbzr('init')
370
428
 
371
 
        self.assertIsSameRealPath(self.run_bzr('root')[0].rstrip(),
372
 
                                  osutils.pathjoin(self.test_dir, 'branch1'))
 
429
        self.assertEquals(capture('root').rstrip(),
 
430
                          os.path.join(self.test_dir, 'branch1'))
373
431
 
374
432
        progress("status of new file")
375
433
 
377
435
        f.write('hello world!\n')
378
436
        f.close()
379
437
 
380
 
        self.assertEquals(self.run_bzr('unknowns')[0], 'test.txt\n')
381
 
 
382
 
        out = self.run_bzr("status")[0]
383
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
438
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
439
 
 
440
        out = capture("status")
 
441
        assert out == 'unknown:\n  test.txt\n'
 
442
 
 
443
        out = capture("status --all")
 
444
        assert out == "unknown:\n  test.txt\n"
 
445
 
 
446
        out = capture("status test.txt --all")
 
447
        assert out == "unknown:\n  test.txt\n"
384
448
 
385
449
        f = file('test2.txt', 'wt')
386
450
        f.write('goodbye cruel world...\n')
387
451
        f.close()
388
452
 
389
 
        out = self.run_bzr("status test.txt")[0]
390
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
453
        out = capture("status test.txt")
 
454
        assert out == "unknown:\n  test.txt\n"
391
455
 
392
 
        out = self.run_bzr("status")[0]
393
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
456
        out = capture("status")
 
457
        assert out == ("unknown:\n"
 
458
                       "  test.txt\n"
 
459
                       "  test2.txt\n")
394
460
 
395
461
        os.unlink('test2.txt')
396
462
 
397
463
        progress("command aliases")
398
 
        out = self.run_bzr("st")[0]
399
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
464
        out = capture("st --all")
 
465
        assert out == ("unknown:\n"
 
466
                       "  test.txt\n")
400
467
 
401
 
        out = self.run_bzr("stat")[0]
402
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
468
        out = capture("stat")
 
469
        assert out == ("unknown:\n"
 
470
                       "  test.txt\n")
403
471
 
404
472
        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')
 
473
        runbzr("help st")
 
474
        runbzr("help")
 
475
        runbzr("help commands")
 
476
        runbzr("help slartibartfast", 1)
 
477
 
 
478
        out = capture("help ci")
 
479
        out.index('aliases: ')
 
480
 
 
481
        progress("can't rename unversioned file")
 
482
        runbzr("rename test.txt new-test.txt", 1)
 
483
 
 
484
        progress("adding a file")
 
485
 
 
486
        runbzr("add test.txt")
 
487
        assert capture("unknowns") == ''
 
488
        assert capture("status --all") == ("added:\n"
 
489
                                                "  test.txt\n")
 
490
 
 
491
        progress("rename newly-added file")
 
492
        runbzr("rename test.txt hello.txt")
 
493
        assert os.path.exists("hello.txt")
 
494
        assert not os.path.exists("test.txt")
 
495
 
 
496
        assert capture("revno") == '0\n'
 
497
 
 
498
        progress("add first revision")
 
499
        runbzr(['commit', '-m', 'add first revision'])
 
500
 
 
501
        progress("more complex renames")
 
502
        os.mkdir("sub1")
 
503
        runbzr("rename hello.txt sub1", 1)
 
504
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
505
        runbzr("move hello.txt sub1", 1)
 
506
 
 
507
        runbzr("add sub1")
 
508
        runbzr("rename sub1 sub2")
 
509
        runbzr("move hello.txt sub2")
 
510
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
511
 
 
512
        assert exists("sub2")
 
513
        assert exists("sub2/hello.txt")
 
514
        assert not exists("sub1")
 
515
        assert not exists("hello.txt")
 
516
 
 
517
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
518
 
 
519
        mkdir("sub1")
 
520
        runbzr('add sub1')
 
521
        runbzr('move sub2/hello.txt sub1')
 
522
        assert not exists('sub2/hello.txt')
 
523
        assert exists('sub1/hello.txt')
 
524
        runbzr('move sub2 sub1')
 
525
        assert not exists('sub2')
 
526
        assert exists('sub1/sub2')
 
527
 
 
528
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
529
 
 
530
        chdir('sub1/sub2')
 
531
        self.assertEquals(capture('root')[:-1],
 
532
                          os.path.join(self.test_dir, 'branch1'))
 
533
        runbzr('move ../hello.txt .')
 
534
        assert exists('./hello.txt')
 
535
        self.assertEquals(capture('relpath hello.txt'),
 
536
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
537
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
538
        runbzr(['commit', '-m', 'move to parent directory'])
 
539
        chdir('..')
 
540
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
541
 
 
542
        runbzr('move sub2/hello.txt .')
 
543
        assert exists('hello.txt')
412
544
 
413
545
        f = file('hello.txt', 'wt')
414
546
        f.write('some nice new content\n')
415
547
        f.close()
416
548
 
417
 
        self.run_bzr("add hello.txt")
418
 
 
419
549
        f = file('msg.tmp', 'wt')
420
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
550
        f.write('this is my new commit\n')
421
551
        f.close()
422
552
 
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]
434
 
        self.assert_("this is my new commit\n  and" in log_out)
435
 
        self.assert_("rename nested" not in log_out)
436
 
        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)
 
553
        runbzr('commit -F msg.tmp')
 
554
 
 
555
        assert capture('revno') == '5\n'
 
556
        runbzr('export -r 5 export-5.tmp')
 
557
        runbzr('export export.tmp')
 
558
 
 
559
        runbzr('log')
 
560
        runbzr('log -v')
 
561
        runbzr('log -v --forward')
 
562
        runbzr('log -m', retcode=1)
 
563
        log_out = capture('log -m commit')
 
564
        assert "this is my new commit" in log_out
 
565
        assert "rename nested" not in log_out
 
566
        assert 'revision-id' not in log_out
 
567
        assert 'revision-id' in capture('log --show-ids -m commit')
 
568
 
447
569
 
448
570
        progress("file with spaces in name")
449
571
        mkdir('sub directory')
450
572
        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():
462
 
            progress("symlinks")
463
 
            mkdir('symlinks')
464
 
            chdir('symlinks')
465
 
            self.run_bzr('init')
466
 
            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
 
 
471
 
            mkdir('d1')
472
 
            self.run_bzr('add d1')
473
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
474
 
            os.symlink("NOWHERE2", "d1/link2")
475
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd1/link2\n')
476
 
            # is d1/link2 found when adding d1
477
 
            self.run_bzr('add d1')
478
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
479
 
            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')
486
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
487
 
            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
 
 
493
 
            os.unlink("link2")
494
 
            os.symlink("TARGET 2", "link2")
495
 
            os.unlink("d2/link1")
496
 
            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'])
504
 
            # 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
 
 
511
 
            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')
521
 
            chdir("exp1.tmp")
522
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
523
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
524
 
            chdir("..")
525
 
 
526
 
            self.run_bzr('export -r 2 exp2.tmp')
527
 
            chdir("exp2.tmp")
528
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
529
 
            chdir("..")
530
 
 
531
 
            self.run_bzr('export -r 3 exp3.tmp')
532
 
            chdir("exp3.tmp")
533
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
534
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
535
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
536
 
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
537
 
            chdir("..")
538
 
 
539
 
            self.run_bzr('export -r 4 exp4.tmp')
540
 
            chdir("exp4.tmp")
541
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
542
 
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
543
 
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
544
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
545
 
            chdir("..")
546
 
 
547
 
            self.run_bzr('export -r 5 exp5.tmp')
548
 
            chdir("exp5.tmp")
549
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
550
 
            self.assert_(os.path.islink("link2"))
551
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
552
 
            chdir("..")
553
 
 
554
 
            self.run_bzr('export -r 8 exp6.tmp')
555
 
            chdir("exp6.tmp")
556
 
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
557
 
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
558
 
            self.assertEquals(listdir_sorted("d2"), [])
559
 
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
560
 
            chdir("..")
561
 
        else:
562
 
            progress("skipping symlink tests")
563
 
 
564
 
 
565
 
class RemoteTests(object):
566
 
    """Test bzr ui commands against remote branches."""
567
 
 
568
 
    def test_branch(self):
569
 
        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'])
575
 
        branch = Branch.open('to')
576
 
        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
 
 
580
 
    def test_log(self):
581
 
        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]
587
 
        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
 
573
        runbzr('add .')
 
574
        runbzr('diff')
 
575
        runbzr('commit -m add-spaces')
 
576
        runbzr('check')
 
577
 
 
578
        runbzr('log')
 
579
        runbzr('log --forward')
 
580
 
 
581
        runbzr('info')
 
582