~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-19 08:19:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050319081938-596d89f99a644569
use "/usr/bin/env python" for shebang"

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
# -*- coding: utf-8 -*-
3
 
 
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
 
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
 
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
 
19
 
"""Black-box tests for bzr.
20
 
 
21
 
These check that it behaves properly when it's invoked through the regular
22
 
command-line interface.
23
 
 
24
 
This always reinvokes bzr through a new Python interpreter, which is a
25
 
bit inefficient but arguably tests in a way more representative of how
26
 
it's normally invoked.
27
 
"""
28
 
 
29
 
from cStringIO import StringIO
30
 
import sys
31
 
import os
32
 
 
33
 
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
34
 
from bzrlib.branch import Branch
35
 
from bzrlib.commands import run_bzr
36
 
 
37
 
 
38
 
class ExternalBase(TestCaseInTempDir):
39
 
    def runbzr(self, args, retcode=0, backtick=False):
40
 
        if isinstance(args, basestring):
41
 
            args = args.split()
42
 
 
43
 
        if backtick:
44
 
            return self.run_bzr_captured(args, retcode=retcode)[0]
45
 
        else:
46
 
            return self.run_bzr_captured(args, retcode=retcode)
47
 
 
48
 
 
49
 
class TestCommands(ExternalBase):
50
 
 
51
 
    def test_help_commands(self):
52
 
        self.runbzr('--help')
53
 
        self.runbzr('help')
54
 
        self.runbzr('help commands')
55
 
        self.runbzr('help help')
56
 
        self.runbzr('commit -h')
57
 
 
58
 
    def test_init_branch(self):
59
 
        self.runbzr(['init'])
60
 
 
61
 
    def test_whoami(self):
62
 
        # this should always identify something, if only "john@localhost"
63
 
        self.runbzr("whoami")
64
 
        self.runbzr("whoami --email")
65
 
 
66
 
        self.assertEquals(self.runbzr("whoami --email",
67
 
                                      backtick=True).count('@'), 1)
68
 
        
69
 
    def test_whoami_branch(self):
70
 
        """branch specific user identity works."""
71
 
        self.runbzr('init')
72
 
        f = file('.bzr/email', 'wt')
73
 
        f.write('Branch Identity <branch@identi.ty>')
74
 
        f.close()
75
 
        bzr_email = os.environ.get('BZREMAIL')
76
 
        if bzr_email is not None:
77
 
            del os.environ['BZREMAIL']
78
 
        whoami = self.runbzr("whoami",backtick=True)
79
 
        whoami_email = self.runbzr("whoami --email",backtick=True)
80
 
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
81
 
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
82
 
        # Verify that the environment variable overrides the value 
83
 
        # in the file
84
 
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
85
 
        whoami = self.runbzr("whoami",backtick=True)
86
 
        whoami_email = self.runbzr("whoami --email",backtick=True)
87
 
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
88
 
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
89
 
        if bzr_email is not None:
90
 
            os.environ['BZREMAIL'] = bzr_email
91
 
 
92
 
    def test_invalid_commands(self):
93
 
        self.runbzr("pants", retcode=1)
94
 
        self.runbzr("--pants off", retcode=1)
95
 
        self.runbzr("diff --message foo", retcode=1)
96
 
 
97
 
    def test_empty_commit(self):
98
 
        self.runbzr("init")
99
 
        self.build_tree(['hello.txt'])
100
 
        self.runbzr("commit -m empty", retcode=1)
101
 
        self.runbzr("add hello.txt")
102
 
        self.runbzr("commit -m added")
103
 
 
104
 
    def test_ignore_patterns(self):
105
 
        from bzrlib.branch import Branch
106
 
        
107
 
        b = Branch.initialize('.')
108
 
        self.assertEquals(list(b.unknowns()), [])
109
 
 
110
 
        file('foo.tmp', 'wt').write('tmp files are ignored')
111
 
        self.assertEquals(list(b.unknowns()), [])
112
 
        assert self.capture('unknowns') == ''
113
 
 
114
 
        file('foo.c', 'wt').write('int main() {}')
115
 
        self.assertEquals(list(b.unknowns()), ['foo.c'])
116
 
        assert self.capture('unknowns') == 'foo.c\n'
117
 
 
118
 
        self.runbzr(['add', 'foo.c'])
119
 
        assert self.capture('unknowns') == ''
120
 
 
121
 
        # 'ignore' works when creating the .bzignore file
122
 
        file('foo.blah', 'wt').write('blah')
123
 
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
124
 
        self.runbzr('ignore *.blah')
125
 
        self.assertEquals(list(b.unknowns()), [])
126
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
127
 
 
128
 
        # 'ignore' works when then .bzrignore file already exists
129
 
        file('garh', 'wt').write('garh')
130
 
        self.assertEquals(list(b.unknowns()), ['garh'])
131
 
        assert self.capture('unknowns') == 'garh\n'
132
 
        self.runbzr('ignore garh')
133
 
        self.assertEquals(list(b.unknowns()), [])
134
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
135
 
 
136
 
    def test_revert(self):
137
 
        self.runbzr('init')
138
 
 
139
 
        file('hello', 'wt').write('foo')
140
 
        self.runbzr('add hello')
141
 
        self.runbzr('commit -m setup hello')
142
 
 
143
 
        file('goodbye', 'wt').write('baz')
144
 
        self.runbzr('add goodbye')
145
 
        self.runbzr('commit -m setup goodbye')
146
 
        
147
 
        file('hello', 'wt').write('bar')
148
 
        file('goodbye', 'wt').write('qux')
149
 
        self.runbzr('revert hello')
150
 
        self.check_file_contents('hello', 'foo')
151
 
        self.check_file_contents('goodbye', 'qux')
152
 
        self.runbzr('revert')
153
 
        self.check_file_contents('goodbye', 'baz')
154
 
 
155
 
        os.mkdir('revertdir')
156
 
        self.runbzr('add revertdir')
157
 
        self.runbzr('commit -m f')
158
 
        os.rmdir('revertdir')
159
 
        self.runbzr('revert')
160
 
 
161
 
        file('hello', 'wt').write('xyz')
162
 
        self.runbzr('commit -m xyz hello')
163
 
        self.runbzr('revert -r 1 hello')
164
 
        self.check_file_contents('hello', 'foo')
165
 
        self.runbzr('revert hello')
166
 
        self.check_file_contents('hello', 'xyz')
167
 
 
168
 
    def test_mv_modes(self):
169
 
        """Test two modes of operation for mv"""
170
 
        from bzrlib.branch import Branch
171
 
        b = Branch.initialize('.')
172
 
        self.build_tree(['a', 'c', 'subdir/'])
173
 
        self.run_bzr('add', self.test_dir)
174
 
        self.run_bzr('mv', 'a', 'b')
175
 
        self.run_bzr('mv', 'b', 'subdir')
176
 
        self.run_bzr('mv', 'subdir/b', 'a')
177
 
        self.run_bzr('mv', 'a', 'c', 'subdir')
178
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
179
 
 
180
 
 
181
 
    def test_main_version(self):
182
 
        """Check output from version command and master option is reasonable"""
183
 
        # output is intentionally passed through to stdout so that we
184
 
        # can see the version being tested
185
 
        output = self.runbzr('version', backtick=1)
186
 
        self.log('bzr version output:')
187
 
        self.log(output)
188
 
        self.assert_(output.startswith('bzr (bazaar-ng) '))
189
 
        self.assertNotEqual(output.index('Canonical'), -1)
190
 
        # make sure --version is consistent
191
 
        tmp_output = self.runbzr('--version', backtick=1)
192
 
        self.log('bzr --version output:')
193
 
        self.log(tmp_output)
194
 
        self.assertEquals(output, tmp_output)
195
 
 
196
 
    def example_branch(test):
197
 
        test.runbzr('init')
198
 
        file('hello', 'wt').write('foo')
199
 
        test.runbzr('add hello')
200
 
        test.runbzr('commit -m setup hello')
201
 
        file('goodbye', 'wt').write('baz')
202
 
        test.runbzr('add goodbye')
203
 
        test.runbzr('commit -m setup goodbye')
204
 
 
205
 
    def test_diff(self):
206
 
        self.example_branch()
207
 
        file('hello', 'wt').write('hello world!')
208
 
        self.runbzr('commit -m fixing hello')
209
 
        output = self.runbzr('diff -r 2..3', backtick=1)
210
 
        self.assert_('\n+hello world!' in output)
211
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
212
 
        self.assert_('\n+baz' in output)
213
 
 
214
 
    def test_diff(self):
215
 
        self.example_branch()
216
 
        file('hello', 'wt').write('hello world!')
217
 
        self.runbzr('commit -m fixing hello')
218
 
        output = self.runbzr('diff -r 2..3', backtick=1)
219
 
        self.assert_('\n+hello world!' in output)
220
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
221
 
        self.assert_('\n+baz' in output)
222
 
 
223
 
    def test_merge(self):
224
 
        from bzrlib.branch import Branch
225
 
        
226
 
        os.mkdir('a')
227
 
        os.chdir('a')
228
 
        self.example_branch()
229
 
        os.chdir('..')
230
 
        self.runbzr('branch a b')
231
 
        os.chdir('b')
232
 
        file('goodbye', 'wt').write('quux')
233
 
        self.runbzr(['commit',  '-m',  "more u's are always good"])
234
 
 
235
 
        os.chdir('../a')
236
 
        file('hello', 'wt').write('quuux')
237
 
        # We can't merge when there are in-tree changes
238
 
        self.runbzr('merge ../b', retcode=1)
239
 
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
240
 
        self.runbzr('merge ../b')
241
 
        self.check_file_contents('goodbye', 'quux')
242
 
        # Merging a branch pulls its revision into the tree
243
 
        a = Branch.open('.')
244
 
        b = Branch.open('../b')
245
 
        a.get_revision_xml(b.last_patch())
246
 
        self.log('pending merges: %s', a.pending_merges())
247
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
248
 
        #        % (a.pending_merges(), b.last_patch())
249
 
 
250
 
    def test_pull(self):
251
 
        """Pull changes from one branch to another."""
252
 
        os.mkdir('a')
253
 
        os.chdir('a')
254
 
 
255
 
        self.example_branch()
256
 
        self.runbzr('pull', retcode=1)
257
 
        self.runbzr('missing', retcode=1)
258
 
        self.runbzr('missing .')
259
 
        self.runbzr('missing')
260
 
        self.runbzr('pull')
261
 
        self.runbzr('pull /', retcode=1)
262
 
        self.runbzr('pull')
263
 
 
264
 
        os.chdir('..')
265
 
        self.runbzr('branch a b')
266
 
        os.chdir('b')
267
 
        self.runbzr('pull')
268
 
        self.runbzr('commit -m blah --unchanged')
269
 
        os.chdir('../a')
270
 
        a = Branch.open('.')
271
 
        b = Branch.open('../b')
272
 
        assert a.revision_history() == b.revision_history()[:-1]
273
 
        self.runbzr('pull ../b')
274
 
        assert a.revision_history() == b.revision_history()
275
 
        self.runbzr('commit -m blah2 --unchanged')
276
 
        os.chdir('../b')
277
 
        self.runbzr('commit -m blah3 --unchanged')
278
 
        self.runbzr('pull ../a', retcode=1)
279
 
        os.chdir('../a')
280
 
        self.runbzr('merge ../b')
281
 
        self.runbzr('commit -m blah4 --unchanged')
282
 
        os.chdir('../b')
283
 
        self.runbzr('pull ../a')
284
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
285
 
        
286
 
    def test_add_reports(self):
287
 
        """add command prints the names of added files."""
288
 
        b = Branch.initialize('.')
289
 
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
290
 
        out = StringIO()
291
 
        ret = self.apply_redirected(None, out, None,
292
 
                                    run_bzr,
293
 
                                    ['add'])
294
 
        self.assertEquals(ret, 0)
295
 
        # the ordering is not defined at the moment
296
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
297
 
        self.assertEquals(['added dir',
298
 
                           'added dir/sub.txt',
299
 
                           'added top.txt',],
300
 
                          results)
301
 
 
302
 
    def test_unknown_command(self):
303
 
        """Handling of unknown command."""
304
 
        out, err = self.run_bzr_captured(['fluffy-badger'],
305
 
                                         retcode=1)
306
 
        self.assertEquals(out, '')
307
 
        err.index('unknown command')
308
 
        
309
 
 
310
 
 
311
 
class OldTests(ExternalBase):
312
 
    """old tests moved from ./testbzr."""
313
 
 
314
 
    def test_bzr(self):
315
 
        from os import chdir, mkdir
316
 
        from os.path import exists
317
 
 
318
 
        runbzr = self.runbzr
319
 
        capture = self.capture
320
 
        progress = self.log
321
 
 
322
 
        progress("basic branch creation")
323
 
        mkdir('branch1')
324
 
        chdir('branch1')
325
 
        runbzr('init')
326
 
 
327
 
        self.assertEquals(capture('root').rstrip(),
328
 
                          os.path.join(self.test_dir, 'branch1'))
329
 
 
330
 
        progress("status of new file")
331
 
 
332
 
        f = file('test.txt', 'wt')
333
 
        f.write('hello world!\n')
334
 
        f.close()
335
 
 
336
 
        self.assertEquals(capture('unknowns'), 'test.txt\n')
337
 
 
338
 
        out = capture("status")
339
 
        assert out == 'unknown:\n  test.txt\n'
340
 
 
341
 
        out = capture("status --all")
342
 
        assert out == "unknown:\n  test.txt\n"
343
 
 
344
 
        out = capture("status test.txt --all")
345
 
        assert out == "unknown:\n  test.txt\n"
346
 
 
347
 
        f = file('test2.txt', 'wt')
348
 
        f.write('goodbye cruel world...\n')
349
 
        f.close()
350
 
 
351
 
        out = capture("status test.txt")
352
 
        assert out == "unknown:\n  test.txt\n"
353
 
 
354
 
        out = capture("status")
355
 
        assert out == ("unknown:\n"
356
 
                       "  test.txt\n"
357
 
                       "  test2.txt\n")
358
 
 
359
 
        os.unlink('test2.txt')
360
 
 
361
 
        progress("command aliases")
362
 
        out = capture("st --all")
363
 
        assert out == ("unknown:\n"
364
 
                       "  test.txt\n")
365
 
 
366
 
        out = capture("stat")
367
 
        assert out == ("unknown:\n"
368
 
                       "  test.txt\n")
369
 
 
370
 
        progress("command help")
371
 
        runbzr("help st")
372
 
        runbzr("help")
373
 
        runbzr("help commands")
374
 
        runbzr("help slartibartfast", 1)
375
 
 
376
 
        out = capture("help ci")
377
 
        out.index('aliases: ')
378
 
 
379
 
        progress("can't rename unversioned file")
380
 
        runbzr("rename test.txt new-test.txt", 1)
381
 
 
382
 
        progress("adding a file")
383
 
 
384
 
        runbzr("add test.txt")
385
 
        assert capture("unknowns") == ''
386
 
        assert capture("status --all") == ("added:\n"
387
 
                                                "  test.txt\n")
388
 
 
389
 
        progress("rename newly-added file")
390
 
        runbzr("rename test.txt hello.txt")
391
 
        assert os.path.exists("hello.txt")
392
 
        assert not os.path.exists("test.txt")
393
 
 
394
 
        assert capture("revno") == '0\n'
395
 
 
396
 
        progress("add first revision")
397
 
        runbzr(['commit', '-m', 'add first revision'])
398
 
 
399
 
        progress("more complex renames")
400
 
        os.mkdir("sub1")
401
 
        runbzr("rename hello.txt sub1", 1)
402
 
        runbzr("rename hello.txt sub1/hello.txt", 1)
403
 
        runbzr("move hello.txt sub1", 1)
404
 
 
405
 
        runbzr("add sub1")
406
 
        runbzr("rename sub1 sub2")
407
 
        runbzr("move hello.txt sub2")
408
 
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
409
 
 
410
 
        assert exists("sub2")
411
 
        assert exists("sub2/hello.txt")
412
 
        assert not exists("sub1")
413
 
        assert not exists("hello.txt")
414
 
 
415
 
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
416
 
 
417
 
        mkdir("sub1")
418
 
        runbzr('add sub1')
419
 
        runbzr('move sub2/hello.txt sub1')
420
 
        assert not exists('sub2/hello.txt')
421
 
        assert exists('sub1/hello.txt')
422
 
        runbzr('move sub2 sub1')
423
 
        assert not exists('sub2')
424
 
        assert exists('sub1/sub2')
425
 
 
426
 
        runbzr(['commit', '-m', 'rename nested subdirectories'])
427
 
 
428
 
        chdir('sub1/sub2')
429
 
        self.assertEquals(capture('root')[:-1],
430
 
                          os.path.join(self.test_dir, 'branch1'))
431
 
        runbzr('move ../hello.txt .')
432
 
        assert exists('./hello.txt')
433
 
        self.assertEquals(capture('relpath hello.txt'),
434
 
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
435
 
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
436
 
        runbzr(['commit', '-m', 'move to parent directory'])
437
 
        chdir('..')
438
 
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
439
 
 
440
 
        runbzr('move sub2/hello.txt .')
441
 
        assert exists('hello.txt')
442
 
 
443
 
        f = file('hello.txt', 'wt')
444
 
        f.write('some nice new content\n')
445
 
        f.close()
446
 
 
447
 
        f = file('msg.tmp', 'wt')
448
 
        f.write('this is my new commit\n')
449
 
        f.close()
450
 
 
451
 
        runbzr('commit -F msg.tmp')
452
 
 
453
 
        assert capture('revno') == '5\n'
454
 
        runbzr('export -r 5 export-5.tmp')
455
 
        runbzr('export export.tmp')
456
 
 
457
 
        runbzr('log')
458
 
        runbzr('log -v')
459
 
        runbzr('log -v --forward')
460
 
        runbzr('log -m', retcode=1)
461
 
        log_out = capture('log -m commit')
462
 
        assert "this is my new commit" in log_out
463
 
        assert "rename nested" not in log_out
464
 
        assert 'revision-id' not in log_out
465
 
        assert 'revision-id' in capture('log --show-ids -m commit')
466
 
 
467
 
 
468
 
        progress("file with spaces in name")
469
 
        mkdir('sub directory')
470
 
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
471
 
        runbzr('add .')
472
 
        runbzr('diff')
473
 
        runbzr('commit -m add-spaces')
474
 
        runbzr('check')
475
 
 
476
 
        runbzr('log')
477
 
        runbzr('log --forward')
478
 
 
479
 
        runbzr('info')
480