~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-10-18 23:47:12 UTC
  • mfrom: (0.2.1)
  • Revision ID: robertc@robertcollins.net-20051018234712-45a83974f691c860
Bugfix the new pull --clobber to not generate spurious conflicts.

When --clobber clobbered the history, a bad merge base was used.

Supporting this:
* merge.merge_inner now has tempdir as an optional parameter. (Robert Collins)

* Tree.kind is not recorded at the top level of the hierarchy, as it was
  missing on EmptyTree, leading to a bug with merge on EmptyTrees.
  (Robert Collins)

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