← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

add a clean target

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
 
#
 
3
 
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
6
6
# the Free Software Foundation; either version 2 of the License, or
7
7
# (at your option) any later version.
8
 
#
 
8
 
9
9
# This program is distributed in the hope that it will be useful,
10
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
12
# GNU General Public License for more details.
13
 
#
 
13
 
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
# Mr. Smoketoomuch: I'm sorry?
19
 
# Mr. Bounder: You'd better cut down a little then.
20
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
21
 
#                   then!
22
18
 
23
19
"""Black-box tests for bzr.
24
20
 
25
21
These check that it behaves properly when it's invoked through the regular
26
 
command-line interface. This doesn't actually run a new interpreter but 
27
 
rather starts again from the run_bzr function.
 
22
command-line interface.
 
23
 
 
24
This always reinvokes bzr through a new Python interpreter, which is a
 
25
bit inefficient but arguably tests in a way more representative of how
 
26
it's normally invoked.
28
27
"""
29
28
 
30
 
 
31
 
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
32
 
# Note: Please don't add new tests here, it's too big and bulky.  Instead add
33
 
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
34
 
# UI command/aspect that is being tested.
35
 
 
36
 
 
37
 
from cStringIO import StringIO
 
29
import sys
38
30
import os
39
 
import re
40
 
import sys
41
31
 
42
 
import bzrlib
43
 
from bzrlib import (
44
 
    osutils,
45
 
    )
 
32
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
46
33
from bzrlib.branch import Branch
47
 
from bzrlib.errors import BzrCommandError
48
 
from bzrlib.osutils import (
49
 
    has_symlinks,
50
 
    pathjoin,
51
 
    terminal_width,
52
 
    )
53
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
54
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
55
 
from bzrlib.tests.blackbox import ExternalBase
56
 
from bzrlib.workingtree import WorkingTree
 
34
from bzrlib.commands import run_bzr
 
35
 
 
36
 
 
37
class ExternalBase(TestCaseInTempDir):
 
38
    def runbzr(self, args, retcode=0,backtick=False):
 
39
        if isinstance(args, basestring):
 
40
            args = args.split()
 
41
 
 
42
        if backtick:
 
43
            return self.backtick(['python', self.BZRPATH,] + args,
 
44
                           retcode=retcode)
 
45
        else:
 
46
            return self.runcmd(['python', self.BZRPATH,] + args,
 
47
                           retcode=retcode)
57
48
 
58
49
 
59
50
class TestCommands(ExternalBase):
60
51
 
 
52
    def test_help_commands(self):
 
53
        self.runbzr('--help')
 
54
        self.runbzr('help')
 
55
        self.runbzr('help commands')
 
56
        self.runbzr('help help')
 
57
        self.runbzr('commit -h')
 
58
 
 
59
    def test_init_branch(self):
 
60
        self.runbzr(['init'])
 
61
 
 
62
    def test_whoami(self):
 
63
        # this should always identify something, if only "john@localhost"
 
64
        self.runbzr("whoami")
 
65
        self.runbzr("whoami --email")
 
66
 
 
67
        self.assertEquals(self.runbzr("whoami --email",
 
68
                                      backtick=True).count('@'), 1)
 
69
        
 
70
    def test_whoami_branch(self):
 
71
        """branch specific user identity works."""
 
72
        self.runbzr('init')
 
73
        f = file('.bzr/email', 'wt')
 
74
        f.write('Branch Identity <branch@identi.ty>')
 
75
        f.close()
 
76
        whoami = self.runbzr("whoami",backtick=True)
 
77
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
78
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
79
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
80
 
61
81
    def test_invalid_commands(self):
62
 
        self.runbzr("pants", retcode=3)
63
 
        self.runbzr("--pants off", retcode=3)
64
 
        self.runbzr("diff --message foo", retcode=3)
 
82
        self.runbzr("pants", retcode=1)
 
83
        self.runbzr("--pants off", retcode=1)
 
84
        self.runbzr("diff --message foo", retcode=1)
 
85
 
 
86
    def test_empty_commit(self):
 
87
        self.runbzr("init")
 
88
        self.build_tree(['hello.txt'])
 
89
        self.runbzr("commit -m empty", retcode=1)
 
90
        self.runbzr("add hello.txt")
 
91
        self.runbzr("commit -m added")
 
92
 
 
93
    def test_ignore_patterns(self):
 
94
        from bzrlib.branch import Branch
 
95
        
 
96
        b = Branch('.', init=True)
 
97
        self.assertEquals(list(b.unknowns()), [])
 
98
 
 
99
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
100
        self.assertEquals(list(b.unknowns()), [])
 
101
        assert self.backtick('bzr unknowns') == ''
 
102
 
 
103
        file('foo.c', 'wt').write('int main() {}')
 
104
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
105
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
106
 
 
107
        self.runbzr(['add', 'foo.c'])
 
108
        assert self.backtick('bzr unknowns') == ''
 
109
 
 
110
        # 'ignore' works when creating the .bzignore file
 
111
        file('foo.blah', 'wt').write('blah')
 
112
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
113
        self.runbzr('ignore *.blah')
 
114
        self.assertEquals(list(b.unknowns()), [])
 
115
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
116
 
 
117
        # 'ignore' works when then .bzrignore file already exists
 
118
        file('garh', 'wt').write('garh')
 
119
        self.assertEquals(list(b.unknowns()), ['garh'])
 
120
        assert self.backtick('bzr unknowns') == 'garh\n'
 
121
        self.runbzr('ignore garh')
 
122
        self.assertEquals(list(b.unknowns()), [])
 
123
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
65
124
 
66
125
    def test_revert(self):
67
126
        self.runbzr('init')
73
132
        file('goodbye', 'wt').write('baz')
74
133
        self.runbzr('add goodbye')
75
134
        self.runbzr('commit -m setup goodbye')
76
 
 
 
135
        
77
136
        file('hello', 'wt').write('bar')
78
137
        file('goodbye', 'wt').write('qux')
79
138
        self.runbzr('revert hello')
88
147
        os.rmdir('revertdir')
89
148
        self.runbzr('revert')
90
149
 
91
 
        if has_symlinks():
92
 
            os.symlink('/unlikely/to/exist', 'symlink')
93
 
            self.runbzr('add symlink')
94
 
            self.runbzr('commit -m f')
95
 
            os.unlink('symlink')
96
 
            self.runbzr('revert')
97
 
            self.failUnlessExists('symlink')
98
 
            os.unlink('symlink')
99
 
            os.symlink('a-different-path', 'symlink')
100
 
            self.runbzr('revert')
101
 
            self.assertEqual('/unlikely/to/exist',
102
 
                             os.readlink('symlink'))
103
 
        else:
104
 
            self.log("skipping revert symlink tests")
105
 
        
106
 
        file('hello', 'wt').write('xyz')
107
 
        self.runbzr('commit -m xyz hello')
108
 
        self.runbzr('revert -r 1 hello')
109
 
        self.check_file_contents('hello', 'foo')
110
 
        self.runbzr('revert hello')
111
 
        self.check_file_contents('hello', 'xyz')
112
 
        os.chdir('revertdir')
113
 
        self.runbzr('revert')
114
 
        os.chdir('..')
 
150
    def test_mv_modes(self):
 
151
        """Test two modes of operation for mv"""
 
152
        from bzrlib.branch import Branch
 
153
        b = Branch('.', init=True)
 
154
        self.build_tree(['a', 'c', 'subdir/'])
 
155
        self.run_bzr('add', self.test_dir)
 
156
        self.run_bzr('mv', 'a', 'b')
 
157
        self.run_bzr('mv', 'b', 'subdir')
 
158
        self.run_bzr('mv', 'subdir/b', 'a')
 
159
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
160
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
161
 
115
162
 
116
163
    def test_main_version(self):
117
164
        """Check output from version command and master option is reasonable"""
120
167
        output = self.runbzr('version', backtick=1)
121
168
        self.log('bzr version output:')
122
169
        self.log(output)
123
 
        self.assert_(output.startswith('Bazaar (bzr) '))
 
170
        self.assert_(output.startswith('bzr (bazaar-ng) '))
124
171
        self.assertNotEqual(output.index('Canonical'), -1)
125
172
        # make sure --version is consistent
126
173
        tmp_output = self.runbzr('--version', backtick=1)
137
184
        test.runbzr('add goodbye')
138
185
        test.runbzr('commit -m setup goodbye')
139
186
 
140
 
    def test_pull_verbose(self):
141
 
        """Pull changes from one branch to another and watch the output."""
142
 
 
143
 
        os.mkdir('a')
144
 
        os.chdir('a')
145
 
 
146
 
        bzr = self.runbzr
 
187
    def test_revert(self):
147
188
        self.example_branch()
148
 
 
149
 
        os.chdir('..')
150
 
        bzr('branch a b')
151
 
        os.chdir('b')
152
 
        open('b', 'wb').write('else\n')
153
 
        bzr('add b')
154
 
        bzr(['commit', '-m', 'added b'])
155
 
 
156
 
        os.chdir('../a')
157
 
        out = bzr('pull --verbose ../b', backtick=True)
158
 
        self.failIfEqual(out.find('Added Revisions:'), -1)
159
 
        self.failIfEqual(out.find('message:\n  added b'), -1)
160
 
        self.failIfEqual(out.find('added b'), -1)
161
 
 
162
 
        # Check that --overwrite --verbose prints out the removed entries
163
 
        bzr('commit -m foo --unchanged')
164
 
        os.chdir('../b')
165
 
        bzr('commit -m baz --unchanged')
166
 
        bzr('pull ../a', retcode=3)
167
 
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
168
 
 
169
 
        remove_loc = out.find('Removed Revisions:')
170
 
        self.failIfEqual(remove_loc, -1)
171
 
        added_loc = out.find('Added Revisions:')
172
 
        self.failIfEqual(added_loc, -1)
173
 
 
174
 
        removed_message = out.find('message:\n  baz')
175
 
        self.failIfEqual(removed_message, -1)
176
 
        self.failUnless(remove_loc < removed_message < added_loc)
177
 
 
178
 
        added_message = out.find('message:\n  foo')
179
 
        self.failIfEqual(added_message, -1)
180
 
        self.failUnless(added_loc < added_message)
 
189
        file('hello', 'wt').write('bar')
 
190
        file('goodbye', 'wt').write('qux')
 
191
        self.runbzr('revert hello')
 
192
        self.check_file_contents('hello', 'foo')
 
193
        self.check_file_contents('goodbye', 'qux')
 
194
        self.runbzr('revert')
 
195
        self.check_file_contents('goodbye', 'baz')
 
196
 
 
197
    def test_merge(self):
 
198
        from bzrlib.branch import Branch
181
199
        
182
 
    def test_locations(self):
183
 
        """Using and remembering different locations"""
184
 
        os.mkdir('a')
185
 
        os.chdir('a')
186
 
        self.runbzr('init')
187
 
        self.runbzr('commit -m unchanged --unchanged')
188
 
        self.runbzr('pull', retcode=3)
189
 
        self.runbzr('merge', retcode=3)
190
 
        self.runbzr('branch . ../b')
191
 
        os.chdir('../b')
192
 
        self.runbzr('pull')
193
 
        self.runbzr('branch . ../c')
194
 
        self.runbzr('pull ../c')
195
 
        self.runbzr('merge')
196
 
        os.chdir('../a')
 
200
        os.mkdir('a')
 
201
        os.chdir('a')
 
202
        self.example_branch()
 
203
        os.chdir('..')
 
204
        self.runbzr('branch a b')
 
205
        os.chdir('b')
 
206
        file('goodbye', 'wt').write('quux')
 
207
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
208
 
 
209
        os.chdir('../a')
 
210
        file('hello', 'wt').write('quuux')
 
211
        # We can't merge when there are in-tree changes
 
212
        self.runbzr('merge ../b', retcode=1)
 
213
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
214
        self.runbzr('merge ../b')
 
215
        self.check_file_contents('goodbye', 'quux')
 
216
        # Merging a branch pulls its revision into the tree
 
217
        a = Branch('.')
 
218
        b = Branch('../b')
 
219
        a.get_revision_xml(b.last_patch())
 
220
        self.log('pending merges: %s', a.pending_merges())
 
221
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
222
        #        % (a.pending_merges(), b.last_patch())
 
223
 
 
224
    def test_pull(self):
 
225
        """Pull changes from one branch to another."""
 
226
        os.mkdir('a')
 
227
        os.chdir('a')
 
228
 
 
229
        self.example_branch()
 
230
        self.runbzr('pull', retcode=1)
 
231
        self.runbzr('missing', retcode=1)
 
232
        self.runbzr('missing .')
 
233
        self.runbzr('missing')
 
234
        self.runbzr('pull')
 
235
        self.runbzr('pull /', retcode=1)
 
236
        self.runbzr('pull')
 
237
 
 
238
        os.chdir('..')
 
239
        self.runbzr('branch a b')
 
240
        os.chdir('b')
 
241
        self.runbzr('pull')
 
242
        self.runbzr('commit -m blah --unchanged')
 
243
        os.chdir('../a')
 
244
        a = Branch('.')
 
245
        b = Branch('../b')
 
246
        assert a.revision_history() == b.revision_history()[:-1]
197
247
        self.runbzr('pull ../b')
198
 
        self.runbzr('pull')
199
 
        self.runbzr('pull ../c')
200
 
        self.runbzr('branch ../c ../d')
201
 
        osutils.rmtree('../c')
202
 
        self.runbzr('pull')
203
 
        os.chdir('../b')
204
 
        self.runbzr('pull')
205
 
        os.chdir('../d')
206
 
        self.runbzr('pull', retcode=3)
207
 
        self.runbzr('pull ../a --remember')
208
 
        self.runbzr('pull')
209
 
        
210
 
    def test_unknown_command(self):
211
 
        """Handling of unknown command."""
212
 
        out, err = self.run_bzr_captured(['fluffy-badger'],
213
 
                                         retcode=3)
214
 
        self.assertEquals(out, '')
215
 
        err.index('unknown command')
216
 
 
217
 
    def create_conflicts(self):
218
 
        """Create a conflicted tree"""
219
 
        os.mkdir('base')
220
 
        os.chdir('base')
221
 
        file('hello', 'wb').write("hi world")
222
 
        file('answer', 'wb').write("42")
223
 
        self.runbzr('init')
224
 
        self.runbzr('add')
225
 
        self.runbzr('commit -m base')
226
 
        self.runbzr('branch . ../other')
227
 
        self.runbzr('branch . ../this')
228
 
        os.chdir('../other')
229
 
        file('hello', 'wb').write("Hello.")
230
 
        file('answer', 'wb').write("Is anyone there?")
231
 
        self.runbzr('commit -m other')
232
 
        os.chdir('../this')
233
 
        file('hello', 'wb').write("Hello, world")
234
 
        self.runbzr('mv answer question')
235
 
        file('question', 'wb').write("What do you get when you multiply six"
236
 
                                   "times nine?")
237
 
        self.runbzr('commit -m this')
238
 
 
239
 
    def test_status(self):
240
 
        os.mkdir('branch1')
241
 
        os.chdir('branch1')
242
 
        self.runbzr('init')
243
 
        self.runbzr('commit --unchanged --message f')
244
 
        self.runbzr('branch . ../branch2')
245
 
        self.runbzr('branch . ../branch3')
246
 
        self.runbzr('commit --unchanged --message peter')
247
 
        os.chdir('../branch2')
248
 
        self.runbzr('merge ../branch1')
249
 
        self.runbzr('commit --unchanged --message pumpkin')
250
 
        os.chdir('../branch3')
251
 
        self.runbzr('merge ../branch2')
252
 
        message = self.capture('status')
253
 
 
254
 
 
255
 
    def test_conflicts(self):
256
 
        """Handling of merge conflicts"""
257
 
        self.create_conflicts()
258
 
        self.runbzr('merge ../other --show-base', retcode=1)
259
 
        conflict_text = file('hello').read()
260
 
        self.assert_('<<<<<<<' in conflict_text)
261
 
        self.assert_('>>>>>>>' in conflict_text)
262
 
        self.assert_('=======' in conflict_text)
263
 
        self.assert_('|||||||' in conflict_text)
264
 
        self.assert_('hi world' in conflict_text)
265
 
        self.runbzr('revert')
266
 
        self.runbzr('resolve --all')
267
 
        self.runbzr('merge ../other', retcode=1)
268
 
        conflict_text = file('hello').read()
269
 
        self.assert_('|||||||' not in conflict_text)
270
 
        self.assert_('hi world' not in conflict_text)
271
 
        result = self.runbzr('conflicts', backtick=1)
272
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
273
 
                                  " question\n")
274
 
        result = self.runbzr('status', backtick=1)
275
 
        self.assert_("conflicts:\n  Text conflict in hello\n"
276
 
                     "  Text conflict in question\n" in result, result)
277
 
        self.runbzr('resolve hello')
278
 
        result = self.runbzr('conflicts', backtick=1)
279
 
        self.assertEquals(result, "Text conflict in question\n")
280
 
        self.runbzr('commit -m conflicts', retcode=3)
281
 
        self.runbzr('resolve --all')
282
 
        result = self.runbzr('conflicts', backtick=1)
283
 
        self.runbzr('commit -m conflicts')
284
 
        self.assertEquals(result, "")
285
 
 
286
 
    def test_push(self):
287
 
        # create a source branch
288
 
        os.mkdir('my-branch')
289
 
        os.chdir('my-branch')
290
 
        self.example_branch()
291
 
 
292
 
        # with no push target, fail
293
 
        self.runbzr('push', retcode=3)
294
 
        # with an explicit target work
295
 
        self.runbzr('push ../output-branch')
296
 
        # with an implicit target work
297
 
        self.runbzr('push')
298
 
        # nothing missing
299
 
        self.runbzr('missing ../output-branch')
300
 
        # advance this branch
301
 
        self.runbzr('commit --unchanged -m unchanged')
302
 
 
303
 
        os.chdir('../output-branch')
304
 
        # There is no longer a difference as long as we have
305
 
        # access to the working tree
306
 
        self.runbzr('diff')
307
 
 
308
 
        # But we should be missing a revision
309
 
        self.runbzr('missing ../my-branch', retcode=1)
310
 
 
311
 
        # diverge the branches
312
 
        self.runbzr('commit --unchanged -m unchanged')
313
 
        os.chdir('../my-branch')
314
 
        # cannot push now
315
 
        self.runbzr('push', retcode=3)
316
 
        # and there are difference
317
 
        self.runbzr('missing ../output-branch', retcode=1)
318
 
        self.runbzr('missing --verbose ../output-branch', retcode=1)
319
 
        # but we can force a push
320
 
        self.runbzr('push --overwrite')
321
 
        # nothing missing
322
 
        self.runbzr('missing ../output-branch')
323
 
        
324
 
        # pushing to a new dir with no parent should fail
325
 
        self.runbzr('push ../missing/new-branch', retcode=3)
326
 
        # unless we provide --create-prefix
327
 
        self.runbzr('push --create-prefix ../missing/new-branch')
328
 
        # nothing missing
329
 
        self.runbzr('missing ../missing/new-branch')
330
 
 
331
 
    def test_external_command(self):
332
 
        """Test that external commands can be run by setting the path
333
 
        """
334
 
        # We don't at present run bzr in a subprocess for blackbox tests, and so 
335
 
        # don't really capture stdout, only the internal python stream.
336
 
        # Therefore we don't use a subcommand that produces any output or does
337
 
        # anything -- we just check that it can be run successfully.  
338
 
        cmd_name = 'test-command'
339
 
        if sys.platform == 'win32':
340
 
            cmd_name += '.bat'
341
 
        oldpath = os.environ.get('BZRPATH', None)
342
 
        bzr = self.capture
343
 
        try:
344
 
            if 'BZRPATH' in os.environ:
345
 
                del os.environ['BZRPATH']
346
 
 
347
 
            f = file(cmd_name, 'wb')
348
 
            if sys.platform == 'win32':
349
 
                f.write('@echo off\n')
350
 
            else:
351
 
                f.write('#!/bin/sh\n')
352
 
            # f.write('echo Hello from test-command')
353
 
            f.close()
354
 
            os.chmod(cmd_name, 0755)
355
 
 
356
 
            # It should not find the command in the local 
357
 
            # directory by default, since it is not in my path
358
 
            bzr(cmd_name, retcode=3)
359
 
 
360
 
            # Now put it into my path
361
 
            os.environ['BZRPATH'] = '.'
362
 
 
363
 
            bzr(cmd_name)
364
 
 
365
 
            # Make sure empty path elements are ignored
366
 
            os.environ['BZRPATH'] = os.pathsep
367
 
 
368
 
            bzr(cmd_name, retcode=3)
369
 
 
370
 
        finally:
371
 
            if oldpath:
372
 
                os.environ['BZRPATH'] = oldpath
373
 
 
374
 
 
375
 
def listdir_sorted(dir):
376
 
    L = os.listdir(dir)
377
 
    L.sort()
378
 
    return L
 
248
        assert a.revision_history() == b.revision_history()
 
249
        self.runbzr('commit -m blah2 --unchanged')
 
250
        os.chdir('../b')
 
251
        self.runbzr('commit -m blah3 --unchanged')
 
252
        self.runbzr('pull ../a', retcode=1)
 
253
        os.chdir('../a')
 
254
        self.runbzr('merge ../b')
 
255
        self.runbzr('commit -m blah4 --unchanged')
 
256
        os.chdir('../b')
 
257
        self.runbzr('pull ../a')
 
258
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
259
        
 
260
 
 
261
    def test_add_reports(self):
 
262
        """add command prints the names of added files."""
 
263
        b = Branch('.', init=True)
 
264
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
265
 
 
266
        from cStringIO import StringIO
 
267
        out = StringIO()
 
268
 
 
269
        ret = self.apply_redirected(None, out, None,
 
270
                                    run_bzr,
 
271
                                    ['add'])
 
272
        self.assertEquals(ret, 0)
 
273
 
 
274
        # the ordering is not defined at the moment
 
275
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
276
        self.assertEquals(['added dir',
 
277
                           'added dir/sub.txt',
 
278
                           'added top.txt',],
 
279
                          results)
379
280
 
380
281
 
381
282
class OldTests(ExternalBase):
386
287
        from os.path import exists
387
288
 
388
289
        runbzr = self.runbzr
389
 
        capture = self.capture
 
290
        backtick = self.backtick
390
291
        progress = self.log
391
292
 
392
293
        progress("basic branch creation")
394
295
        chdir('branch1')
395
296
        runbzr('init')
396
297
 
397
 
        self.assertEquals(capture('root').rstrip(),
398
 
                          pathjoin(self.test_dir, 'branch1'))
 
298
        self.assertEquals(backtick('bzr root').rstrip(),
 
299
                          os.path.join(self.test_dir, 'branch1'))
399
300
 
400
301
        progress("status of new file")
401
302
 
403
304
        f.write('hello world!\n')
404
305
        f.close()
405
306
 
406
 
        self.assertEquals(capture('unknowns'), 'test.txt\n')
407
 
 
408
 
        out = capture("status")
409
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
307
        out = backtick("bzr unknowns")
 
308
        self.assertEquals(out, 'test.txt\n')
 
309
 
 
310
        out = backtick("bzr status")
 
311
        assert out == 'unknown:\n  test.txt\n'
 
312
 
 
313
        out = backtick("bzr status --all")
 
314
        assert out == "unknown:\n  test.txt\n"
 
315
 
 
316
        out = backtick("bzr status test.txt --all")
 
317
        assert out == "unknown:\n  test.txt\n"
410
318
 
411
319
        f = file('test2.txt', 'wt')
412
320
        f.write('goodbye cruel world...\n')
413
321
        f.close()
414
322
 
415
 
        out = capture("status test.txt")
416
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
323
        out = backtick("bzr status test.txt")
 
324
        assert out == "unknown:\n  test.txt\n"
417
325
 
418
 
        out = capture("status")
419
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
326
        out = backtick("bzr status")
 
327
        assert out == ("unknown:\n"
 
328
                       "  test.txt\n"
 
329
                       "  test2.txt\n")
420
330
 
421
331
        os.unlink('test2.txt')
422
332
 
423
333
        progress("command aliases")
424
 
        out = capture("st")
425
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
334
        out = backtick("bzr st --all")
 
335
        assert out == ("unknown:\n"
 
336
                       "  test.txt\n")
426
337
 
427
 
        out = capture("stat")
428
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
338
        out = backtick("bzr stat")
 
339
        assert out == ("unknown:\n"
 
340
                       "  test.txt\n")
429
341
 
430
342
        progress("command help")
431
343
        runbzr("help st")
432
344
        runbzr("help")
433
345
        runbzr("help commands")
434
 
        runbzr("help slartibartfast", 3)
435
 
 
436
 
        out = capture("help ci")
437
 
        out.index('aliases: ci, checkin\n')
 
346
        runbzr("help slartibartfast", 1)
 
347
 
 
348
        out = backtick("bzr help ci")
 
349
        out.index('aliases: ')
 
350
 
 
351
        progress("can't rename unversioned file")
 
352
        runbzr("rename test.txt new-test.txt", 1)
 
353
 
 
354
        progress("adding a file")
 
355
 
 
356
        runbzr("add test.txt")
 
357
        assert backtick("bzr unknowns") == ''
 
358
        assert backtick("bzr status --all") == ("added:\n"
 
359
                                                "  test.txt\n")
 
360
 
 
361
        progress("rename newly-added file")
 
362
        runbzr("rename test.txt hello.txt")
 
363
        assert os.path.exists("hello.txt")
 
364
        assert not os.path.exists("test.txt")
 
365
 
 
366
        assert backtick("bzr revno") == '0\n'
 
367
 
 
368
        progress("add first revision")
 
369
        runbzr(['commit', '-m', 'add first revision'])
 
370
 
 
371
        progress("more complex renames")
 
372
        os.mkdir("sub1")
 
373
        runbzr("rename hello.txt sub1", 1)
 
374
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
375
        runbzr("move hello.txt sub1", 1)
 
376
 
 
377
        runbzr("add sub1")
 
378
        runbzr("rename sub1 sub2")
 
379
        runbzr("move hello.txt sub2")
 
380
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
381
 
 
382
        assert exists("sub2")
 
383
        assert exists("sub2/hello.txt")
 
384
        assert not exists("sub1")
 
385
        assert not exists("hello.txt")
 
386
 
 
387
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
388
 
 
389
        mkdir("sub1")
 
390
        runbzr('add sub1')
 
391
        runbzr('move sub2/hello.txt sub1')
 
392
        assert not exists('sub2/hello.txt')
 
393
        assert exists('sub1/hello.txt')
 
394
        runbzr('move sub2 sub1')
 
395
        assert not exists('sub2')
 
396
        assert exists('sub1/sub2')
 
397
 
 
398
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
399
 
 
400
        chdir('sub1/sub2')
 
401
        self.assertEquals(backtick('bzr root')[:-1],
 
402
                          os.path.join(self.test_dir, 'branch1'))
 
403
        runbzr('move ../hello.txt .')
 
404
        assert exists('./hello.txt')
 
405
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
406
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
407
        runbzr(['commit', '-m', 'move to parent directory'])
 
408
        chdir('..')
 
409
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
410
 
 
411
        runbzr('move sub2/hello.txt .')
 
412
        assert exists('hello.txt')
438
413
 
439
414
        f = file('hello.txt', 'wt')
440
415
        f.write('some nice new content\n')
441
416
        f.close()
442
417
 
443
 
        runbzr("add hello.txt")
444
 
        
445
418
        f = file('msg.tmp', 'wt')
446
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
419
        f.write('this is my new commit\n')
447
420
        f.close()
448
421
 
449
422
        runbzr('commit -F msg.tmp')
450
423
 
451
 
        self.assertEquals(capture('revno'), '1\n')
452
 
        runbzr('export -r 1 export-1.tmp')
 
424
        assert backtick('bzr revno') == '5\n'
 
425
        runbzr('export -r 5 export-5.tmp')
453
426
        runbzr('export export.tmp')
454
427
 
455
428
        runbzr('log')
456
429
        runbzr('log -v')
457
430
        runbzr('log -v --forward')
458
 
        runbzr('log -m', retcode=3)
459
 
        log_out = capture('log -m commit')
460
 
        self.assert_("this is my new commit\n  and" in log_out)
461
 
        self.assert_("rename nested" not in log_out)
462
 
        self.assert_('revision-id' not in log_out)
463
 
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
431
        runbzr('log -m', retcode=1)
 
432
        log_out = backtick('bzr log -m commit')
 
433
        assert "this is my new commit" in log_out
 
434
        assert "rename nested" not in log_out
 
435
        assert 'revision-id' not in log_out
 
436
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
464
437
 
465
 
        log_out = capture('log --line')
466
 
        # determine the widest line we want
467
 
        max_width = terminal_width() - 1
468
 
        for line in log_out.splitlines():
469
 
            self.assert_(len(line) <= max_width, len(line))
470
 
        self.assert_("this is my new commit and" not in log_out)
471
 
        self.assert_("this is my new commit" in log_out)
472
438
 
473
439
        progress("file with spaces in name")
474
440
        mkdir('sub directory')
475
441
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
476
442
        runbzr('add .')
477
 
        runbzr('diff', retcode=1)
 
443
        runbzr('diff')
478
444
        runbzr('commit -m add-spaces')
479
445
        runbzr('check')
480
446
 
483
449
 
484
450
        runbzr('info')
485
451
 
486
 
        if has_symlinks():
487
 
            progress("symlinks")
488
 
            mkdir('symlinks')
489
 
            chdir('symlinks')
490
 
            runbzr('init')
491
 
            os.symlink("NOWHERE1", "link1")
492
 
            runbzr('add link1')
493
 
            self.assertEquals(self.capture('unknowns'), '')
494
 
            runbzr(['commit', '-m', '1: added symlink link1'])
495
 
    
496
 
            mkdir('d1')
497
 
            runbzr('add d1')
498
 
            self.assertEquals(self.capture('unknowns'), '')
499
 
            os.symlink("NOWHERE2", "d1/link2")
500
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
501
 
            # is d1/link2 found when adding d1
502
 
            runbzr('add d1')
503
 
            self.assertEquals(self.capture('unknowns'), '')
504
 
            os.symlink("NOWHERE3", "d1/link3")
505
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
506
 
            runbzr(['commit', '-m', '2: added dir, symlink'])
507
 
    
508
 
            runbzr('rename d1 d2')
509
 
            runbzr('move d2/link2 .')
510
 
            runbzr('move link1 d2')
511
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
512
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
513
 
            runbzr('add d2/link3')
514
 
            runbzr('diff', retcode=1)
515
 
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
516
 
    
517
 
            os.unlink("link2")
518
 
            os.symlink("TARGET 2", "link2")
519
 
            os.unlink("d2/link1")
520
 
            os.symlink("TARGET 1", "d2/link1")
521
 
            runbzr('diff', retcode=1)
522
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
523
 
            runbzr(['commit', '-m', '4: retarget of two links'])
524
 
    
525
 
            runbzr('remove --keep d2/link1')
526
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
527
 
            runbzr(['commit', '-m', '5: remove d2/link1'])
528
 
            # try with the rm alias
529
 
            runbzr('add d2/link1')
530
 
            runbzr(['commit', '-m', '6: add d2/link1'])
531
 
            runbzr('rm --keep d2/link1')
532
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
533
 
            runbzr(['commit', '-m', '7: remove d2/link1'])
534
 
    
535
 
            os.mkdir("d1")
536
 
            runbzr('add d1')
537
 
            runbzr('rename d2/link3 d1/link3new')
538
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
539
 
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
540
 
            
541
 
            runbzr(['check'])
542
 
            
543
 
            runbzr(['export', '-r', '1', 'exp1.tmp'])
544
 
            chdir("exp1.tmp")
545
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
546
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
547
 
            chdir("..")
548
 
            
549
 
            runbzr(['export', '-r', '2', 'exp2.tmp'])
550
 
            chdir("exp2.tmp")
551
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
552
 
            chdir("..")
553
 
            
554
 
            runbzr(['export', '-r', '3', 'exp3.tmp'])
555
 
            chdir("exp3.tmp")
556
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
557
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
558
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
559
 
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
560
 
            chdir("..")
561
 
            
562
 
            runbzr(['export', '-r', '4', 'exp4.tmp'])
563
 
            chdir("exp4.tmp")
564
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
565
 
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
566
 
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
567
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
568
 
            chdir("..")
569
 
            
570
 
            runbzr(['export', '-r', '5', 'exp5.tmp'])
571
 
            chdir("exp5.tmp")
572
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
573
 
            self.assert_(os.path.islink("link2"))
574
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
575
 
            chdir("..")
576
 
            
577
 
            runbzr(['export', '-r', '8', 'exp6.tmp'])
578
 
            chdir("exp6.tmp")
579
 
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
580
 
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
581
 
            self.assertEquals(listdir_sorted("d2"), [])
582
 
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
583
 
            chdir("..")
584
 
        else:
585
 
            progress("skipping symlink tests")
586
 
 
587
 
 
588
 
class RemoteTests(object):
589
 
    """Test bzr ui commands against remote branches."""
590
 
 
591
 
    def test_branch(self):
592
 
        os.mkdir('from')
593
 
        wt = self.make_branch_and_tree('from')
594
 
        branch = wt.branch
595
 
        wt.commit('empty commit for nonsense', allow_pointless=True)
596
 
        url = self.get_readonly_url('from')
597
 
        self.run_bzr('branch', url, 'to')
598
 
        branch = Branch.open('to')
599
 
        self.assertEqual(1, len(branch.revision_history()))
600
 
        # the branch should be set in to to from
601
 
        self.assertEqual(url + '/', branch.get_parent())
602
 
 
603
 
    def test_log(self):
604
 
        self.build_tree(['branch/', 'branch/file'])
605
 
        self.capture('init branch')
606
 
        self.capture('add branch/file')
607
 
        self.capture('commit -m foo branch')
608
 
        url = self.get_readonly_url('branch/file')
609
 
        output = self.capture('log %s' % url)
610
 
        self.assertEqual(8, len(output.split('\n')))
611
 
        
612
 
    def test_check(self):
613
 
        self.build_tree(['branch/', 'branch/file'])
614
 
        self.capture('init branch')
615
 
        self.capture('add branch/file')
616
 
        self.capture('commit -m foo branch')
617
 
        url = self.get_readonly_url('branch/')
618
 
        self.run_bzr('check', url)
619
 
    
620
 
    def test_push(self):
621
 
        # create a source branch
622
 
        os.mkdir('my-branch')
623
 
        os.chdir('my-branch')
624
 
        self.run_bzr('init')
625
 
        file('hello', 'wt').write('foo')
626
 
        self.run_bzr('add', 'hello')
627
 
        self.run_bzr('commit', '-m', 'setup')
628
 
 
629
 
        # with an explicit target work
630
 
        self.run_bzr('push', self.get_url('output-branch'))
631
 
 
632
 
    
633
 
class HTTPTests(TestCaseWithWebserver, RemoteTests):
634
 
    """Test various commands against a HTTP server."""
635
 
    
636
 
    
637
 
class SFTPTestsAbsolute(TestCaseWithSFTPServer, RemoteTests):
638
 
    """Test various commands against a SFTP server using abs paths."""
639
 
 
640
 
    
641
 
class SFTPTestsAbsoluteSibling(TestCaseWithSFTPServer, RemoteTests):
642
 
    """Test various commands against a SFTP server using abs paths."""
643
 
 
644
 
    def setUp(self):
645
 
        super(SFTPTestsAbsoluteSibling, self).setUp()
646
 
        self._override_home = '/dev/noone/runs/tests/here'
647
 
 
648
 
    
649
 
class SFTPTestsRelative(TestCaseWithSFTPServer, RemoteTests):
650
 
    """Test various commands against a SFTP server using homedir rel paths."""
651
 
 
652
 
    def setUp(self):
653
 
        super(SFTPTestsRelative, self).setUp()
654
 
        self._get_remote_is_absolute = False