/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: Robert Collins
  • Date: 2005-10-29 23:48:45 UTC
  • Revision ID: robertc@robertcollins.net-20051029234845-7ae4e7d118bdd3ed
Implement a 'bzr push' command, with saved locations; update diff to return 1.

    * 'bzr diff' now returns 1 when there are changes in the working 
      tree.

    * 'bzr push' now exists and can push changes to a remote location. 
      This uses the transport infrastructure, and can store the remote
      location in the ~/.bazaar/branches.conf configuration file.

    * WorkingTree.pull has been split across Branch and WorkingTree,
      to allow Branch only pulls.

    * commands.display_command now returns the result of the decorated 
      function.

    * LocationConfig now has a set_user_option(key, value) call to save
      a setting in its matching location section (a new one is created
      if needed).

    * Branch has two new methods, get_push_location and set_push_location
      to respectively, get and set the push location.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
# Mr. Smoketoomuch: I'm sorry?
18
 
# Mr. Bounder: You'd better cut down a little then.
19
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
20
 
#                   then!
21
18
 
22
19
"""Black-box tests for bzr.
23
20
 
24
21
These check that it behaves properly when it's invoked through the regular
25
 
command-line interface. This doesn't actually run a new interpreter but
 
22
command-line interface. This doesn't actually run a new interpreter but 
26
23
rather starts again from the run_bzr function.
27
24
"""
28
25
 
29
26
 
30
 
# 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_other_branch_commit(self):
 
115
        # this branch is to ensure consistent behaviour, whether we're run
 
116
        # inside a branch, or not.
 
117
        os.mkdir('empty_branch')
 
118
        os.chdir('empty_branch')
 
119
        self.runbzr('init')
 
120
        os.mkdir('branch')
 
121
        os.chdir('branch')
 
122
        self.runbzr('init')
 
123
        file('foo.c', 'wt').write('int main() {}')
 
124
        file('bar.c', 'wt').write('int main() {}')
 
125
        os.chdir('..')
 
126
        self.runbzr(['add', 'branch/foo.c'])
 
127
        self.runbzr(['add', 'branch'])
 
128
        # can't commit files in different trees; sane error
 
129
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=1)
 
130
        self.runbzr('commit -m newstuff branch/foo.c')
 
131
        self.runbzr('commit -m newstuff branch')
 
132
        self.runbzr('commit -m newstuff branch', retcode=1)
 
133
 
 
134
 
 
135
    def test_ignore_patterns(self):
 
136
        from bzrlib.branch import Branch
 
137
        
 
138
        b = Branch.initialize('.')
 
139
        self.assertEquals(list(b.unknowns()), [])
 
140
 
 
141
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
142
        self.assertEquals(list(b.unknowns()), [])
 
143
        assert self.capture('unknowns') == ''
 
144
 
 
145
        file('foo.c', 'wt').write('int main() {}')
 
146
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
147
        assert self.capture('unknowns') == 'foo.c\n'
 
148
 
 
149
        self.runbzr(['add', 'foo.c'])
 
150
        assert self.capture('unknowns') == ''
 
151
 
 
152
        # 'ignore' works when creating the .bzignore file
 
153
        file('foo.blah', 'wt').write('blah')
 
154
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
155
        self.runbzr('ignore *.blah')
 
156
        self.assertEquals(list(b.unknowns()), [])
 
157
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
158
 
 
159
        # 'ignore' works when then .bzrignore file already exists
 
160
        file('garh', 'wt').write('garh')
 
161
        self.assertEquals(list(b.unknowns()), ['garh'])
 
162
        assert self.capture('unknowns') == 'garh\n'
 
163
        self.runbzr('ignore garh')
 
164
        self.assertEquals(list(b.unknowns()), [])
 
165
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
59
166
 
60
167
    def test_revert(self):
61
 
        self.run_bzr('init')
 
168
        self.runbzr('init')
62
169
 
63
170
        file('hello', 'wt').write('foo')
64
 
        self.run_bzr('add hello')
65
 
        self.run_bzr('commit -m setup hello')
 
171
        self.runbzr('add hello')
 
172
        self.runbzr('commit -m setup hello')
66
173
 
67
174
        file('goodbye', 'wt').write('baz')
68
 
        self.run_bzr('add goodbye')
69
 
        self.run_bzr('commit -m setup goodbye')
 
175
        self.runbzr('add goodbye')
 
176
        self.runbzr('commit -m setup goodbye')
70
177
 
71
178
        file('hello', 'wt').write('bar')
72
179
        file('goodbye', 'wt').write('qux')
73
 
        self.run_bzr('revert hello')
 
180
        self.runbzr('revert hello')
74
181
        self.check_file_contents('hello', 'foo')
75
182
        self.check_file_contents('goodbye', 'qux')
76
 
        self.run_bzr('revert')
 
183
        self.runbzr('revert')
77
184
        self.check_file_contents('goodbye', 'baz')
78
185
 
79
186
        os.mkdir('revertdir')
80
 
        self.run_bzr('add revertdir')
81
 
        self.run_bzr('commit -m f')
 
187
        self.runbzr('add revertdir')
 
188
        self.runbzr('commit -m f')
82
189
        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
 
 
 
190
        self.runbzr('revert')
 
191
 
 
192
        os.symlink('/unlikely/to/exist', 'symlink')
 
193
        self.runbzr('add symlink')
 
194
        self.runbzr('commit -m f')
 
195
        os.unlink('symlink')
 
196
        self.runbzr('revert')
 
197
        self.failUnlessExists('symlink')
 
198
        os.unlink('symlink')
 
199
        os.symlink('a-different-path', 'symlink')
 
200
        self.runbzr('revert')
 
201
        self.assertEqual('/unlikely/to/exist',
 
202
                         os.readlink('symlink'))
 
203
        
100
204
        file('hello', 'wt').write('xyz')
101
 
        self.run_bzr('commit -m xyz hello')
102
 
        self.run_bzr('revert -r 1 hello')
 
205
        self.runbzr('commit -m xyz hello')
 
206
        self.runbzr('revert -r 1 hello')
103
207
        self.check_file_contents('hello', 'foo')
104
 
        self.run_bzr('revert hello')
 
208
        self.runbzr('revert hello')
105
209
        self.check_file_contents('hello', 'xyz')
106
210
        os.chdir('revertdir')
107
 
        self.run_bzr('revert')
 
211
        self.runbzr('revert')
108
212
        os.chdir('..')
109
213
 
 
214
 
 
215
    def test_mv_modes(self):
 
216
        """Test two modes of operation for mv"""
 
217
        from bzrlib.branch import Branch
 
218
        b = Branch.initialize('.')
 
219
        self.build_tree(['a', 'c', 'subdir/'])
 
220
        self.run_bzr_captured(['add', self.test_dir])
 
221
        self.run_bzr_captured(['mv', 'a', 'b'])
 
222
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
223
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
224
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
225
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
226
 
 
227
    def test_main_version(self):
 
228
        """Check output from version command and master option is reasonable"""
 
229
        # output is intentionally passed through to stdout so that we
 
230
        # can see the version being tested
 
231
        output = self.runbzr('version', backtick=1)
 
232
        self.log('bzr version output:')
 
233
        self.log(output)
 
234
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
235
        self.assertNotEqual(output.index('Canonical'), -1)
 
236
        # make sure --version is consistent
 
237
        tmp_output = self.runbzr('--version', backtick=1)
 
238
        self.log('bzr --version output:')
 
239
        self.log(tmp_output)
 
240
        self.assertEquals(output, tmp_output)
 
241
 
110
242
    def example_branch(test):
111
 
        test.run_bzr('init')
 
243
        test.runbzr('init')
112
244
        file('hello', 'wt').write('foo')
113
 
        test.run_bzr('add hello')
114
 
        test.run_bzr('commit -m setup hello')
 
245
        test.runbzr('add hello')
 
246
        test.runbzr('commit -m setup hello')
115
247
        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)
 
248
        test.runbzr('add goodbye')
 
249
        test.runbzr('commit -m setup goodbye')
 
250
 
 
251
    def test_export(self):
 
252
        os.mkdir('branch')
 
253
        os.chdir('branch')
 
254
        self.example_branch()
 
255
        self.runbzr('export ../latest')
 
256
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
257
        self.runbzr('export ../first -r 1')
 
258
        assert not os.path.exists('../first/goodbye')
 
259
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
260
        self.runbzr('export ../first.gz -r 1')
 
261
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
262
        self.runbzr('export ../first.bz2 -r 1')
 
263
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
264
        self.runbzr('export ../first.tar -r 1')
 
265
        assert os.path.isfile('../first.tar')
 
266
        from tarfile import TarFile
 
267
        tf = TarFile('../first.tar')
 
268
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
269
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
270
        self.runbzr('export ../first.tar.gz -r 1')
 
271
        assert os.path.isfile('../first.tar.gz')
 
272
        self.runbzr('export ../first.tbz2 -r 1')
 
273
        assert os.path.isfile('../first.tbz2')
 
274
        self.runbzr('export ../first.tar.bz2 -r 1')
 
275
        assert os.path.isfile('../first.tar.bz2')
 
276
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
277
        assert os.path.isfile('../first.tar.tbz2')
 
278
        from bz2 import BZ2File
 
279
        tf = TarFile('../first.tar.tbz2', 
 
280
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
281
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
282
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
283
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
284
        tf = TarFile('../first2.tar')
 
285
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
286
 
 
287
    def test_diff(self):
 
288
        self.example_branch()
 
289
        file('hello', 'wt').write('hello world!')
 
290
        self.runbzr('commit -m fixing hello')
 
291
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
 
292
        self.assert_('\n+hello world!' in output)
 
293
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
 
294
        self.assert_('\n+baz' in output)
 
295
 
 
296
    def test_diff_branches(self):
 
297
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
298
        branch = Branch.initialize('branch1')
 
299
        branch.add(['file'])
 
300
        branch.commit('add file')
 
301
        copy_branch(branch, 'branch2')
 
302
        print >> open('branch2/file', 'w'), 'new content'
 
303
        branch2 = Branch.open('branch2')
 
304
        branch2.commit('update file')
 
305
        # should open branch1 and diff against branch2, 
 
306
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
307
                                        'branch1'],
 
308
                                       retcode=1)
 
309
        self.assertEquals(("=== modified file 'file'\n"
 
310
                           "--- file\n"
 
311
                           "+++ file\n"
 
312
                           "@@ -1,1 +1,1 @@\n"
 
313
                           "-new content\n"
 
314
                           "+contents of branch1/file\n"
 
315
                           "\n", ''), output)
 
316
 
 
317
    def test_branch(self):
 
318
        """Branch from one branch to another."""
 
319
        os.mkdir('a')
 
320
        os.chdir('a')
 
321
        self.example_branch()
 
322
        os.chdir('..')
 
323
        self.runbzr('branch a b')
 
324
        self.assertFileEqual('b\n', 'b/.bzr/branch-name')
 
325
        self.runbzr('branch a c -r 1')
 
326
        os.chdir('b')
 
327
        self.runbzr('commit -m foo --unchanged')
 
328
        os.chdir('..')
 
329
        # naughty - abstraction violations RBC 20050928  
 
330
        print "test_branch used to delete the stores, how is this meant to work ?"
 
331
        #shutil.rmtree('a/.bzr/revision-store')
 
332
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
333
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
334
        self.runbzr('branch a d --basis b')
 
335
 
 
336
    def test_merge(self):
 
337
        from bzrlib.branch import Branch
 
338
        
 
339
        os.mkdir('a')
 
340
        os.chdir('a')
 
341
        self.example_branch()
 
342
        os.chdir('..')
 
343
        self.runbzr('branch a b')
 
344
        os.chdir('b')
 
345
        file('goodbye', 'wt').write('quux')
 
346
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
347
 
 
348
        os.chdir('../a')
 
349
        file('hello', 'wt').write('quuux')
 
350
        # We can't merge when there are in-tree changes
 
351
        self.runbzr('merge ../b', retcode=1)
 
352
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
353
        self.runbzr('merge ../b -r last:1..last:1 --merge-type blooof',
 
354
                    retcode=1)
 
355
        self.runbzr('merge ../b -r last:1..last:1 --merge-type merge3')
 
356
        self.runbzr('revert --no-backup')
 
357
        self.runbzr('merge ../b -r last:1..last:1 --merge-type weave')
 
358
        self.runbzr('revert --no-backup')
 
359
        self.runbzr('merge ../b -r last:1')
 
360
        self.check_file_contents('goodbye', 'quux')
 
361
        # Merging a branch pulls its revision into the tree
 
362
        a = Branch.open('.')
 
363
        b = Branch.open('../b')
 
364
        a.get_revision_xml(b.last_revision())
 
365
        self.log('pending merges: %s', a.pending_merges())
 
366
        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
367
            % (a.pending_merges(), b.last_patch())
 
368
        self.runbzr('commit -m merged')
 
369
        self.runbzr('merge ../b -r last:1')
 
370
        self.assertEqual(Branch.open('.').pending_merges(), [])
 
371
 
 
372
 
 
373
    def test_merge_with_missing_file(self):
 
374
        """Merge handles missing file conflicts"""
 
375
        os.mkdir('a')
 
376
        os.chdir('a')
 
377
        os.mkdir('sub')
 
378
        print >> file('sub/a.txt', 'wb'), "hello"
 
379
        print >> file('b.txt', 'wb'), "hello"
 
380
        print >> file('sub/c.txt', 'wb'), "hello"
 
381
        self.runbzr('init')
 
382
        self.runbzr('add')
 
383
        self.runbzr(('commit', '-m', 'added a'))
 
384
        self.runbzr('branch . ../b')
 
385
        print >> file('sub/a.txt', 'ab'), "there"
 
386
        print >> file('b.txt', 'ab'), "there"
 
387
        print >> file('sub/c.txt', 'ab'), "there"
 
388
        self.runbzr(('commit', '-m', 'Added there'))
 
389
        os.unlink('sub/a.txt')
 
390
        os.unlink('sub/c.txt')
 
391
        os.rmdir('sub')
 
392
        os.unlink('b.txt')
 
393
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
394
        os.chdir('../b')
 
395
        print >> file('sub/a.txt', 'ab'), "something"
 
396
        print >> file('b.txt', 'ab'), "something"
 
397
        print >> file('sub/c.txt', 'ab'), "something"
 
398
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
399
        self.runbzr('merge ../a/', retcode=1)
 
400
        assert os.path.exists('sub/a.txt.THIS')
 
401
        assert os.path.exists('sub/a.txt.BASE')
 
402
        os.chdir('../a')
 
403
        self.runbzr('merge ../b/', retcode=1)
 
404
        assert os.path.exists('sub/a.txt.OTHER')
 
405
        assert os.path.exists('sub/a.txt.BASE')
 
406
 
 
407
    def test_pull(self):
 
408
        """Pull changes from one branch to another."""
 
409
        os.mkdir('a')
 
410
        os.chdir('a')
 
411
 
 
412
        self.example_branch()
 
413
        self.runbzr('pull', retcode=1)
 
414
        self.runbzr('missing', retcode=1)
 
415
        self.runbzr('missing .')
 
416
        self.runbzr('missing')
 
417
        self.runbzr('pull')
 
418
        self.runbzr('pull /', retcode=1)
 
419
        self.runbzr('pull')
 
420
 
 
421
        os.chdir('..')
 
422
        self.runbzr('branch a b')
 
423
        os.chdir('b')
 
424
        self.runbzr('pull')
 
425
        os.mkdir('subdir')
 
426
        self.runbzr('add subdir')
 
427
        self.runbzr('commit -m blah --unchanged')
 
428
        os.chdir('../a')
 
429
        a = Branch.open('.')
 
430
        b = Branch.open('../b')
 
431
        assert a.revision_history() == b.revision_history()[:-1]
 
432
        self.runbzr('pull ../b')
 
433
        assert a.revision_history() == b.revision_history()
 
434
        self.runbzr('commit -m blah2 --unchanged')
 
435
        os.chdir('../b')
 
436
        self.runbzr('commit -m blah3 --unchanged')
 
437
        # no overwrite
 
438
        self.runbzr('pull ../a', retcode=1)
 
439
        os.chdir('..')
 
440
        self.runbzr('branch b overwriteme')
 
441
        os.chdir('overwriteme')
 
442
        self.runbzr('pull --overwrite ../a')
 
443
        overwritten = Branch.open('.')
 
444
        self.assertEqual(overwritten.revision_history(),
 
445
                         a.revision_history())
 
446
        os.chdir('../a')
 
447
        self.runbzr('merge ../b')
 
448
        self.runbzr('commit -m blah4 --unchanged')
 
449
        os.chdir('../b/subdir')
 
450
        self.runbzr('pull ../../a')
 
451
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
452
        self.runbzr('commit -m blah5 --unchanged')
 
453
        self.runbzr('commit -m blah6 --unchanged')
 
454
        os.chdir('..')
 
455
        self.runbzr('pull ../a')
 
456
        os.chdir('../a')
 
457
        self.runbzr('commit -m blah7 --unchanged')
 
458
        self.runbzr('merge ../b')
 
459
        self.runbzr('commit -m blah8 --unchanged')
 
460
        self.runbzr('pull ../b')
 
461
        self.runbzr('pull ../b')
159
462
 
160
463
    def test_locations(self):
161
464
        """Using and remembering different locations"""
162
465
        os.mkdir('a')
163
466
        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')
 
467
        self.runbzr('init')
 
468
        self.runbzr('commit -m unchanged --unchanged')
 
469
        self.runbzr('pull', retcode=1)
 
470
        self.runbzr('merge', retcode=1)
 
471
        self.runbzr('branch . ../b')
169
472
        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')
 
473
        self.runbzr('pull')
 
474
        self.runbzr('branch . ../c')
 
475
        self.runbzr('pull ../c')
 
476
        self.runbzr('merge')
174
477
        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')
 
478
        self.runbzr('pull ../b')
 
479
        self.runbzr('pull')
 
480
        self.runbzr('pull ../c')
 
481
        self.runbzr('branch ../c ../d')
 
482
        shutil.rmtree('../c')
 
483
        self.runbzr('pull')
181
484
        os.chdir('../b')
182
 
        self.run_bzr('pull')
 
485
        self.runbzr('pull')
183
486
        os.chdir('../d')
184
 
        self.run_bzr('pull', retcode=3)
185
 
        self.run_bzr('pull ../a --remember')
186
 
        self.run_bzr('pull')
 
487
        self.runbzr('pull', retcode=1)
 
488
        self.runbzr('pull ../a --remember')
 
489
        self.runbzr('pull')
 
490
        
 
491
    def test_add_reports(self):
 
492
        """add command prints the names of added files."""
 
493
        b = Branch.initialize('.')
 
494
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
495
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
496
        # the ordering is not defined at the moment
 
497
        results = sorted(out.rstrip('\n').split('\n'))
 
498
        self.assertEquals(['added dir',
 
499
                           'added dir'+os.sep+'sub.txt',
 
500
                           'added top.txt',],
 
501
                          results)
 
502
 
 
503
    def test_add_quiet_is(self):
 
504
        """add -q does not print the names of added files."""
 
505
        b = Branch.initialize('.')
 
506
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
507
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
508
        # the ordering is not defined at the moment
 
509
        results = sorted(out.rstrip('\n').split('\n'))
 
510
        self.assertEquals([''], results)
187
511
 
188
512
    def test_unknown_command(self):
189
513
        """Handling of unknown command."""
190
 
        out, err = self.run_bzr('fluffy-badger', retcode=3)
 
514
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
515
                                         retcode=1)
191
516
        self.assertEquals(out, '')
192
517
        err.index('unknown command')
193
518
 
194
 
    def create_conflicts(self):
195
 
        """Create a conflicted tree"""
 
519
    def test_conflicts(self):
 
520
        """Handling of merge conflicts"""
196
521
        os.mkdir('base')
197
522
        os.chdir('base')
198
523
        file('hello', 'wb').write("hi world")
199
524
        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')
 
525
        self.runbzr('init')
 
526
        self.runbzr('add')
 
527
        self.runbzr('commit -m base')
 
528
        self.runbzr('branch . ../other')
 
529
        self.runbzr('branch . ../this')
205
530
        os.chdir('../other')
206
531
        file('hello', 'wb').write("Hello.")
207
532
        file('answer', 'wb').write("Is anyone there?")
208
 
        self.run_bzr('commit -m other')
 
533
        self.runbzr('commit -m other')
209
534
        os.chdir('../this')
210
535
        file('hello', 'wb').write("Hello, world")
211
 
        self.run_bzr('mv answer question')
 
536
        self.runbzr('mv answer question')
212
537
        file('question', 'wb').write("What do you get when you multiply six"
213
538
                                   "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')
 
539
        self.runbzr('commit -m this')
 
540
        self.runbzr('merge ../other --show-base', retcode=1)
 
541
        conflict_text = file('hello').read()
 
542
        assert '<<<<<<<' in conflict_text
 
543
        assert '>>>>>>>' in conflict_text
 
544
        assert '=======' in conflict_text
 
545
        assert '|||||||' in conflict_text
 
546
        assert 'hi world' in conflict_text
 
547
        self.runbzr('revert')
 
548
        self.runbzr('resolve --all')
 
549
        self.runbzr('merge ../other', retcode=1)
 
550
        conflict_text = file('hello').read()
 
551
        assert '|||||||' not in conflict_text
 
552
        assert 'hi world' not in conflict_text
 
553
        result = self.runbzr('conflicts', backtick=1)
 
554
        self.assertEquals(result, "hello\nquestion\n")
 
555
        result = self.runbzr('status', backtick=1)
 
556
        assert "conflicts:\n  hello\n  question\n" in result, result
 
557
        self.runbzr('resolve hello')
 
558
        result = self.runbzr('conflicts', backtick=1)
 
559
        self.assertEquals(result, "question\n")
 
560
        self.runbzr('commit -m conflicts', retcode=1)
 
561
        self.runbzr('resolve --all')
 
562
        result = self.runbzr('conflicts', backtick=1)
 
563
        self.runbzr('commit -m conflicts')
261
564
        self.assertEquals(result, "")
262
565
 
 
566
    def test_resign(self):
 
567
        """Test re signing of data."""
 
568
        import bzrlib.gpg
 
569
        oldstrategy = bzrlib.gpg.GPGStrategy
 
570
        branch = Branch.initialize('.')
 
571
        branch.commit("base", allow_pointless=True, rev_id='A')
 
572
        try:
 
573
            # monkey patch gpg signing mechanism
 
574
            from bzrlib.testament import Testament
 
575
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
576
            self.runbzr('re-sign -r revid:A')
 
577
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
578
                             branch.revision_store.get('A', 'sig').read())
 
579
        finally:
 
580
            bzrlib.gpg.GPGStrategy = oldstrategy
 
581
            
 
582
    def test_resign_range(self):
 
583
        import bzrlib.gpg
 
584
        oldstrategy = bzrlib.gpg.GPGStrategy
 
585
        branch = Branch.initialize('.')
 
586
        branch.commit("base", allow_pointless=True, rev_id='A')
 
587
        branch.commit("base", allow_pointless=True, rev_id='B')
 
588
        branch.commit("base", allow_pointless=True, rev_id='C')
 
589
        try:
 
590
            # monkey patch gpg signing mechanism
 
591
            from bzrlib.testament import Testament
 
592
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
593
            self.runbzr('re-sign -r 1..')
 
594
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
595
                             branch.revision_store.get('A', 'sig').read())
 
596
            self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
 
597
                             branch.revision_store.get('B', 'sig').read())
 
598
            self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
 
599
                             branch.revision_store.get('C', 'sig').read())
 
600
        finally:
 
601
            bzrlib.gpg.GPGStrategy = oldstrategy
 
602
 
263
603
    def test_push(self):
264
604
        # create a source branch
265
605
        os.mkdir('my-branch')
267
607
        self.example_branch()
268
608
 
269
609
        # with no push target, fail
270
 
        self.run_bzr('push', retcode=3)
 
610
        self.runbzr('push', retcode=1)
271
611
        # with an explicit target work
272
 
        self.run_bzr('push ../output-branch')
 
612
        self.runbzr('push ../output-branch')
273
613
        # with an implicit target work
274
 
        self.run_bzr('push')
 
614
        self.runbzr('push')
275
615
        # nothing missing
276
 
        self.run_bzr('missing ../output-branch')
 
616
        self.runbzr('missing ../output-branch')
277
617
        # advance this branch
278
 
        self.run_bzr('commit --unchanged -m unchanged')
 
618
        self.runbzr('commit --unchanged -m unchanged')
279
619
 
280
620
        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
 
 
 
621
        # should be a diff as we have not pushed the tree
 
622
        self.runbzr('diff', retcode=1)
 
623
        self.runbzr('revert')
 
624
        # but not now.
 
625
        self.runbzr('diff')
288
626
        # diverge the branches
289
 
        self.run_bzr('commit --unchanged -m unchanged')
 
627
        self.runbzr('commit --unchanged -m unchanged')
290
628
        os.chdir('../my-branch')
291
629
        # cannot push now
292
 
        self.run_bzr('push', retcode=3)
 
630
        self.runbzr('push', retcode=1)
293
631
        # and there are difference
294
 
        self.run_bzr('missing ../output-branch', retcode=1)
295
 
        self.run_bzr('missing --verbose ../output-branch', retcode=1)
 
632
        self.runbzr('missing ../output-branch', retcode=1)
296
633
        # 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
 
634
        self.runbzr('push --overwrite')
 
635
        # nothing missing
 
636
        self.runbzr('missing ../output-branch')
349
637
 
350
638
 
351
639
def listdir_sorted(dir):
361
649
        from os import chdir, mkdir
362
650
        from os.path import exists
363
651
 
 
652
        runbzr = self.runbzr
 
653
        capture = self.capture
364
654
        progress = self.log
365
655
 
366
656
        progress("basic branch creation")
367
657
        mkdir('branch1')
368
658
        chdir('branch1')
369
 
        self.run_bzr('init')
 
659
        runbzr('init')
370
660
 
371
 
        self.assertIsSameRealPath(self.run_bzr('root')[0].rstrip(),
372
 
                                  osutils.pathjoin(self.test_dir, 'branch1'))
 
661
        self.assertEquals(capture('root').rstrip(),
 
662
                          os.path.join(self.test_dir, 'branch1'))
373
663
 
374
664
        progress("status of new file")
375
665
 
377
667
        f.write('hello world!\n')
378
668
        f.close()
379
669
 
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')
 
670
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
671
 
 
672
        out = capture("status")
 
673
        assert out == 'unknown:\n  test.txt\n'
 
674
 
 
675
        out = capture("status --all")
 
676
        assert out == "unknown:\n  test.txt\n"
 
677
 
 
678
        out = capture("status test.txt --all")
 
679
        assert out == "unknown:\n  test.txt\n"
384
680
 
385
681
        f = file('test2.txt', 'wt')
386
682
        f.write('goodbye cruel world...\n')
387
683
        f.close()
388
684
 
389
 
        out = self.run_bzr("status test.txt")[0]
390
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
685
        out = capture("status test.txt")
 
686
        assert out == "unknown:\n  test.txt\n"
391
687
 
392
 
        out = self.run_bzr("status")[0]
393
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
688
        out = capture("status")
 
689
        assert out == ("unknown:\n"
 
690
                       "  test.txt\n"
 
691
                       "  test2.txt\n")
394
692
 
395
693
        os.unlink('test2.txt')
396
694
 
397
695
        progress("command aliases")
398
 
        out = self.run_bzr("st")[0]
399
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
696
        out = capture("st --all")
 
697
        assert out == ("unknown:\n"
 
698
                       "  test.txt\n")
400
699
 
401
 
        out = self.run_bzr("stat")[0]
402
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
700
        out = capture("stat")
 
701
        assert out == ("unknown:\n"
 
702
                       "  test.txt\n")
403
703
 
404
704
        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')
 
705
        runbzr("help st")
 
706
        runbzr("help")
 
707
        runbzr("help commands")
 
708
        runbzr("help slartibartfast", 1)
 
709
 
 
710
        out = capture("help ci")
 
711
        out.index('aliases: ')
 
712
 
 
713
        progress("can't rename unversioned file")
 
714
        runbzr("rename test.txt new-test.txt", 1)
 
715
 
 
716
        progress("adding a file")
 
717
 
 
718
        runbzr("add test.txt")
 
719
        assert capture("unknowns") == ''
 
720
        assert capture("status --all") == ("added:\n"
 
721
                                                "  test.txt\n")
 
722
 
 
723
        progress("rename newly-added file")
 
724
        runbzr("rename test.txt hello.txt")
 
725
        assert os.path.exists("hello.txt")
 
726
        assert not os.path.exists("test.txt")
 
727
 
 
728
        assert capture("revno") == '0\n'
 
729
 
 
730
        progress("add first revision")
 
731
        runbzr(['commit', '-m', 'add first revision'])
 
732
 
 
733
        progress("more complex renames")
 
734
        os.mkdir("sub1")
 
735
        runbzr("rename hello.txt sub1", 1)
 
736
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
737
        runbzr("move hello.txt sub1", 1)
 
738
 
 
739
        runbzr("add sub1")
 
740
        runbzr("rename sub1 sub2")
 
741
        runbzr("move hello.txt sub2")
 
742
        self.assertEqual(capture("relpath sub2/hello.txt"),
 
743
                         os.path.join("sub2", "hello.txt\n"))
 
744
 
 
745
        assert exists("sub2")
 
746
        assert exists("sub2/hello.txt")
 
747
        assert not exists("sub1")
 
748
        assert not exists("hello.txt")
 
749
 
 
750
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
751
 
 
752
        mkdir("sub1")
 
753
        runbzr('add sub1')
 
754
        runbzr('move sub2/hello.txt sub1')
 
755
        assert not exists('sub2/hello.txt')
 
756
        assert exists('sub1/hello.txt')
 
757
        runbzr('move sub2 sub1')
 
758
        assert not exists('sub2')
 
759
        assert exists('sub1/sub2')
 
760
 
 
761
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
762
 
 
763
        chdir('sub1/sub2')
 
764
        self.assertEquals(capture('root')[:-1],
 
765
                          os.path.join(self.test_dir, 'branch1'))
 
766
        runbzr('move ../hello.txt .')
 
767
        assert exists('./hello.txt')
 
768
        self.assertEquals(capture('relpath hello.txt'),
 
769
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
770
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
771
        runbzr(['commit', '-m', 'move to parent directory'])
 
772
        chdir('..')
 
773
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
774
 
 
775
        runbzr('move sub2/hello.txt .')
 
776
        assert exists('hello.txt')
412
777
 
413
778
        f = file('hello.txt', 'wt')
414
779
        f.write('some nice new content\n')
415
780
        f.close()
416
781
 
417
 
        self.run_bzr("add hello.txt")
418
 
 
419
782
        f = file('msg.tmp', 'wt')
420
783
        f.write('this is my new commit\nand it has multiple lines, for fun')
421
784
        f.close()
422
785
 
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)
 
786
        runbzr('commit -F msg.tmp')
 
787
 
 
788
        assert capture('revno') == '5\n'
 
789
        runbzr('export -r 5 export-5.tmp')
 
790
        runbzr('export export.tmp')
 
791
 
 
792
        runbzr('log')
 
793
        runbzr('log -v')
 
794
        runbzr('log -v --forward')
 
795
        runbzr('log -m', retcode=1)
 
796
        log_out = capture('log -m commit')
 
797
        assert "this is my new commit\n  and" in log_out
 
798
        assert "rename nested" not in log_out
 
799
        assert 'revision-id' not in log_out
 
800
        assert 'revision-id' in capture('log --show-ids -m commit')
 
801
 
 
802
        log_out = capture('log --line')
 
803
        for line in log_out.splitlines():
 
804
            assert len(line) <= 79, len(line)
 
805
        assert "this is my new commit and" in log_out
 
806
 
447
807
 
448
808
        progress("file with spaces in name")
449
809
        mkdir('sub directory')
450
810
        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():
 
811
        runbzr('add .')
 
812
        runbzr('diff', retcode=1)
 
813
        runbzr('commit -m add-spaces')
 
814
        runbzr('check')
 
815
 
 
816
        runbzr('log')
 
817
        runbzr('log --forward')
 
818
 
 
819
        runbzr('info')
 
820
 
 
821
        if has_symlinks():
462
822
            progress("symlinks")
463
823
            mkdir('symlinks')
464
824
            chdir('symlinks')
465
 
            self.run_bzr('init')
 
825
            runbzr('init')
466
826
            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
 
 
 
827
            runbzr('add link1')
 
828
            assert self.capture('unknowns') == ''
 
829
            runbzr(['commit', '-m', '1: added symlink link1'])
 
830
    
471
831
            mkdir('d1')
472
 
            self.run_bzr('add d1')
473
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
 
832
            runbzr('add d1')
 
833
            assert self.capture('unknowns') == ''
474
834
            os.symlink("NOWHERE2", "d1/link2")
475
 
            self.assertEquals(self.run_bzr('unknowns')[0], 'd1/link2\n')
 
835
            assert self.capture('unknowns') == 'd1/link2\n'
476
836
            # is d1/link2 found when adding d1
477
 
            self.run_bzr('add d1')
478
 
            self.assertEquals(self.run_bzr('unknowns')[0], '')
 
837
            runbzr('add d1')
 
838
            assert self.capture('unknowns') == ''
479
839
            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
 
 
 
840
            assert self.capture('unknowns') == 'd1/link3\n'
 
841
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
842
    
 
843
            runbzr('rename d1 d2')
 
844
            runbzr('move d2/link2 .')
 
845
            runbzr('move link1 d2')
 
846
            assert os.readlink("./link2") == "NOWHERE2"
 
847
            assert os.readlink("d2/link1") == "NOWHERE1"
 
848
            runbzr('add d2/link3')
 
849
            runbzr('diff', retcode=1)
 
850
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
851
    
493
852
            os.unlink("link2")
494
853
            os.symlink("TARGET 2", "link2")
495
854
            os.unlink("d2/link1")
496
855
            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'])
 
856
            runbzr('diff', retcode=1)
 
857
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
858
            runbzr(['commit', '-m', '4: retarget of two links'])
 
859
    
 
860
            runbzr('remove d2/link1')
 
861
            assert self.capture('unknowns') == 'd2/link1\n'
 
862
            runbzr(['commit', '-m', '5: remove d2/link1'])
504
863
            # 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
 
 
 
864
            runbzr('add d2/link1')
 
865
            runbzr(['commit', '-m', '6: add d2/link1'])
 
866
            runbzr('rm d2/link1')
 
867
            assert self.capture('unknowns') == 'd2/link1\n'
 
868
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
869
    
511
870
            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')
 
871
            runbzr('add d1')
 
872
            runbzr('rename d2/link3 d1/link3new')
 
873
            assert self.capture('unknowns') == 'd2/link1\n'
 
874
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
875
            
 
876
            runbzr(['check'])
 
877
            
 
878
            runbzr(['export', '-r', '1', 'exp1.tmp'])
521
879
            chdir("exp1.tmp")
522
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
523
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
880
            assert listdir_sorted(".") == [ "link1" ]
 
881
            assert os.readlink("link1") == "NOWHERE1"
524
882
            chdir("..")
525
 
 
526
 
            self.run_bzr('export -r 2 exp2.tmp')
 
883
            
 
884
            runbzr(['export', '-r', '2', 'exp2.tmp'])
527
885
            chdir("exp2.tmp")
528
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
886
            assert listdir_sorted(".") == [ "d1", "link1" ]
529
887
            chdir("..")
530
 
 
531
 
            self.run_bzr('export -r 3 exp3.tmp')
 
888
            
 
889
            runbzr(['export', '-r', '3', 'exp3.tmp'])
532
890
            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")
 
891
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
892
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
893
            assert os.readlink("d2/link1") == "NOWHERE1"
 
894
            assert os.readlink("link2")    == "NOWHERE2"
537
895
            chdir("..")
538
 
 
539
 
            self.run_bzr('export -r 4 exp4.tmp')
 
896
            
 
897
            runbzr(['export', '-r', '4', 'exp4.tmp'])
540
898
            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" ])
 
899
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
900
            assert os.readlink("d2/link1") == "TARGET 1"
 
901
            assert os.readlink("link2")    == "TARGET 2"
 
902
            assert listdir_sorted("d2") == [ "link1", "link3" ]
545
903
            chdir("..")
546
 
 
547
 
            self.run_bzr('export -r 5 exp5.tmp')
 
904
            
 
905
            runbzr(['export', '-r', '5', 'exp5.tmp'])
548
906
            chdir("exp5.tmp")
549
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
550
 
            self.assert_(os.path.islink("link2"))
551
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
907
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
908
            assert os.path.islink("link2")
 
909
            assert listdir_sorted("d2")== [ "link3" ]
552
910
            chdir("..")
553
 
 
554
 
            self.run_bzr('export -r 8 exp6.tmp')
 
911
            
 
912
            runbzr(['export', '-r', '8', 'exp6.tmp'])
555
913
            chdir("exp6.tmp")
556
914
            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")
 
915
            assert listdir_sorted("d1") == [ "link3new" ]
 
916
            assert listdir_sorted("d2") == []
 
917
            assert os.readlink("d1/link3new") == "NOWHERE3"
560
918
            chdir("..")
561
919
        else:
562
920
            progress("skipping symlink tests")
563
921
 
564
922
 
565
 
class RemoteTests(object):
 
923
class HttpTests(TestCaseWithWebserver):
566
924
    """Test bzr ui commands against remote branches."""
567
925
 
568
926
    def test_branch(self):
569
927
        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'])
 
928
        branch = Branch.initialize('from')
 
929
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
930
        url = self.get_remote_url('from')
 
931
        self.run_bzr('branch', url, 'to')
575
932
        branch = Branch.open('to')
576
933
        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
934
 
580
935
    def test_log(self):
581
936
        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
 
937
        branch = Branch.initialize('branch')
 
938
        branch.add(['file'])
 
939
        branch.commit('add file', rev_id='A')
 
940
        url = self.get_remote_url('branch/file')
 
941
        output = self.capture('log %s' % url)
 
942
        self.assertEqual(7, len(output.split('\n')))
 
943
        
 
944
 
 
945
 
 
946