~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Harald Meland
  • Date: 2005-09-23 12:49:00 UTC
  • mto: (1185.1.45)
  • mto: This revision was merged to the branch mainline in revision 1391.
  • Revision ID: hmeland@twoflower.uio.no-20050923124900-fa7d79d29f1e537d
Use fcntl.lockf() rather than fcntl.flock() to support NFS file systems.

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
 
 
36
 
 
37
class ExternalBase(TestCaseInTempDir):
 
38
 
 
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
        os.chdir('revertdir')
 
168
        self.runbzr('revert')
 
169
        os.chdir('..')
 
170
 
 
171
 
 
172
    def test_mv_modes(self):
 
173
        """Test two modes of operation for mv"""
 
174
        from bzrlib.branch import Branch
 
175
        b = Branch.initialize('.')
 
176
        self.build_tree(['a', 'c', 'subdir/'])
 
177
        self.run_bzr_captured(['add', self.test_dir])
 
178
        self.run_bzr_captured(['mv', 'a', 'b'])
 
179
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
180
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
181
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
182
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
183
 
 
184
 
 
185
    def test_main_version(self):
 
186
        """Check output from version command and master option is reasonable"""
 
187
        # output is intentionally passed through to stdout so that we
 
188
        # can see the version being tested
 
189
        output = self.runbzr('version', backtick=1)
 
190
        self.log('bzr version output:')
 
191
        self.log(output)
 
192
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
193
        self.assertNotEqual(output.index('Canonical'), -1)
 
194
        # make sure --version is consistent
 
195
        tmp_output = self.runbzr('--version', backtick=1)
 
196
        self.log('bzr --version output:')
 
197
        self.log(tmp_output)
 
198
        self.assertEquals(output, tmp_output)
 
199
 
 
200
    def example_branch(test):
 
201
        test.runbzr('init')
 
202
        file('hello', 'wt').write('foo')
 
203
        test.runbzr('add hello')
 
204
        test.runbzr('commit -m setup hello')
 
205
        file('goodbye', 'wt').write('baz')
 
206
        test.runbzr('add goodbye')
 
207
        test.runbzr('commit -m setup goodbye')
 
208
 
 
209
    def test_diff(self):
 
210
        self.example_branch()
 
211
        file('hello', 'wt').write('hello world!')
 
212
        self.runbzr('commit -m fixing hello')
 
213
        output = self.runbzr('diff -r 2..3', backtick=1)
 
214
        self.assert_('\n+hello world!' in output)
 
215
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
216
        self.assert_('\n+baz' in output)
 
217
 
 
218
    def test_branch(self):
 
219
        """Branch from one branch to another."""
 
220
        os.mkdir('a')
 
221
        os.chdir('a')
 
222
        self.example_branch()
 
223
        os.chdir('..')
 
224
        self.runbzr('branch a b')
 
225
        self.runbzr('branch a c -r 1')
 
226
 
 
227
    def test_merge(self):
 
228
        from bzrlib.branch import Branch
 
229
        
 
230
        os.mkdir('a')
 
231
        os.chdir('a')
 
232
        self.example_branch()
 
233
        os.chdir('..')
 
234
        self.runbzr('branch a b')
 
235
        os.chdir('b')
 
236
        file('goodbye', 'wt').write('quux')
 
237
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
238
 
 
239
        os.chdir('../a')
 
240
        file('hello', 'wt').write('quuux')
 
241
        # We can't merge when there are in-tree changes
 
242
        self.runbzr('merge ../b', retcode=1)
 
243
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
244
        self.runbzr('merge ../b')
 
245
        self.check_file_contents('goodbye', 'quux')
 
246
        # Merging a branch pulls its revision into the tree
 
247
        a = Branch.open('.')
 
248
        b = Branch.open('../b')
 
249
        a.get_revision_xml(b.last_patch())
 
250
        self.log('pending merges: %s', a.pending_merges())
 
251
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
252
        #        % (a.pending_merges(), b.last_patch())
 
253
 
 
254
    def test_pull(self):
 
255
        """Pull changes from one branch to another."""
 
256
        os.mkdir('a')
 
257
        os.chdir('a')
 
258
 
 
259
        self.example_branch()
 
260
        self.runbzr('pull', retcode=1)
 
261
        self.runbzr('missing', retcode=1)
 
262
        self.runbzr('missing .')
 
263
        self.runbzr('missing')
 
264
        self.runbzr('pull')
 
265
        self.runbzr('pull /', retcode=1)
 
266
        self.runbzr('pull')
 
267
 
 
268
        os.chdir('..')
 
269
        self.runbzr('branch a b')
 
270
        os.chdir('b')
 
271
        self.runbzr('pull')
 
272
        os.mkdir('subdir')
 
273
        self.runbzr('add subdir')
 
274
        self.runbzr('commit -m blah --unchanged')
 
275
        os.chdir('../a')
 
276
        a = Branch.open('.')
 
277
        b = Branch.open('../b')
 
278
        assert a.revision_history() == b.revision_history()[:-1]
 
279
        self.runbzr('pull ../b')
 
280
        assert a.revision_history() == b.revision_history()
 
281
        self.runbzr('commit -m blah2 --unchanged')
 
282
        os.chdir('../b')
 
283
        self.runbzr('commit -m blah3 --unchanged')
 
284
        self.runbzr('pull ../a', retcode=1)
 
285
        os.chdir('../a')
 
286
        self.runbzr('merge ../b')
 
287
        self.runbzr('commit -m blah4 --unchanged')
 
288
        os.chdir('../b/subdir')
 
289
        self.runbzr('pull ../../a')
 
290
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
291
        
 
292
    def test_add_reports(self):
 
293
        """add command prints the names of added files."""
 
294
        b = Branch.initialize('.')
 
295
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
296
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
297
        # the ordering is not defined at the moment
 
298
        results = sorted(out.rstrip('\n').split('\n'))
 
299
        self.assertEquals(['added dir',
 
300
                           'added dir/sub.txt',
 
301
                           'added top.txt',],
 
302
                          results)
 
303
 
 
304
    def test_unknown_command(self):
 
305
        """Handling of unknown command."""
 
306
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
307
                                         retcode=1)
 
308
        self.assertEquals(out, '')
 
309
        err.index('unknown command')
 
310
        
 
311
 
 
312
 
 
313
class OldTests(ExternalBase):
 
314
    """old tests moved from ./testbzr."""
 
315
 
 
316
    def test_bzr(self):
 
317
        from os import chdir, mkdir
 
318
        from os.path import exists
 
319
 
 
320
        runbzr = self.runbzr
 
321
        capture = self.capture
 
322
        progress = self.log
 
323
 
 
324
        progress("basic branch creation")
 
325
        mkdir('branch1')
 
326
        chdir('branch1')
 
327
        runbzr('init')
 
328
 
 
329
        self.assertEquals(capture('root').rstrip(),
 
330
                          os.path.join(self.test_dir, 'branch1'))
 
331
 
 
332
        progress("status of new file")
 
333
 
 
334
        f = file('test.txt', 'wt')
 
335
        f.write('hello world!\n')
 
336
        f.close()
 
337
 
 
338
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
339
 
 
340
        out = capture("status")
 
341
        assert out == 'unknown:\n  test.txt\n'
 
342
 
 
343
        out = capture("status --all")
 
344
        assert out == "unknown:\n  test.txt\n"
 
345
 
 
346
        out = capture("status test.txt --all")
 
347
        assert out == "unknown:\n  test.txt\n"
 
348
 
 
349
        f = file('test2.txt', 'wt')
 
350
        f.write('goodbye cruel world...\n')
 
351
        f.close()
 
352
 
 
353
        out = capture("status test.txt")
 
354
        assert out == "unknown:\n  test.txt\n"
 
355
 
 
356
        out = capture("status")
 
357
        assert out == ("unknown:\n"
 
358
                       "  test.txt\n"
 
359
                       "  test2.txt\n")
 
360
 
 
361
        os.unlink('test2.txt')
 
362
 
 
363
        progress("command aliases")
 
364
        out = capture("st --all")
 
365
        assert out == ("unknown:\n"
 
366
                       "  test.txt\n")
 
367
 
 
368
        out = capture("stat")
 
369
        assert out == ("unknown:\n"
 
370
                       "  test.txt\n")
 
371
 
 
372
        progress("command help")
 
373
        runbzr("help st")
 
374
        runbzr("help")
 
375
        runbzr("help commands")
 
376
        runbzr("help slartibartfast", 1)
 
377
 
 
378
        out = capture("help ci")
 
379
        out.index('aliases: ')
 
380
 
 
381
        progress("can't rename unversioned file")
 
382
        runbzr("rename test.txt new-test.txt", 1)
 
383
 
 
384
        progress("adding a file")
 
385
 
 
386
        runbzr("add test.txt")
 
387
        assert capture("unknowns") == ''
 
388
        assert capture("status --all") == ("added:\n"
 
389
                                                "  test.txt\n")
 
390
 
 
391
        progress("rename newly-added file")
 
392
        runbzr("rename test.txt hello.txt")
 
393
        assert os.path.exists("hello.txt")
 
394
        assert not os.path.exists("test.txt")
 
395
 
 
396
        assert capture("revno") == '0\n'
 
397
 
 
398
        progress("add first revision")
 
399
        runbzr(['commit', '-m', 'add first revision'])
 
400
 
 
401
        progress("more complex renames")
 
402
        os.mkdir("sub1")
 
403
        runbzr("rename hello.txt sub1", 1)
 
404
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
405
        runbzr("move hello.txt sub1", 1)
 
406
 
 
407
        runbzr("add sub1")
 
408
        runbzr("rename sub1 sub2")
 
409
        runbzr("move hello.txt sub2")
 
410
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
411
 
 
412
        assert exists("sub2")
 
413
        assert exists("sub2/hello.txt")
 
414
        assert not exists("sub1")
 
415
        assert not exists("hello.txt")
 
416
 
 
417
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
418
 
 
419
        mkdir("sub1")
 
420
        runbzr('add sub1')
 
421
        runbzr('move sub2/hello.txt sub1')
 
422
        assert not exists('sub2/hello.txt')
 
423
        assert exists('sub1/hello.txt')
 
424
        runbzr('move sub2 sub1')
 
425
        assert not exists('sub2')
 
426
        assert exists('sub1/sub2')
 
427
 
 
428
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
429
 
 
430
        chdir('sub1/sub2')
 
431
        self.assertEquals(capture('root')[:-1],
 
432
                          os.path.join(self.test_dir, 'branch1'))
 
433
        runbzr('move ../hello.txt .')
 
434
        assert exists('./hello.txt')
 
435
        self.assertEquals(capture('relpath hello.txt'),
 
436
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
437
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
438
        runbzr(['commit', '-m', 'move to parent directory'])
 
439
        chdir('..')
 
440
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
441
 
 
442
        runbzr('move sub2/hello.txt .')
 
443
        assert exists('hello.txt')
 
444
 
 
445
        f = file('hello.txt', 'wt')
 
446
        f.write('some nice new content\n')
 
447
        f.close()
 
448
 
 
449
        f = file('msg.tmp', 'wt')
 
450
        f.write('this is my new commit\n')
 
451
        f.close()
 
452
 
 
453
        runbzr('commit -F msg.tmp')
 
454
 
 
455
        assert capture('revno') == '5\n'
 
456
        runbzr('export -r 5 export-5.tmp')
 
457
        runbzr('export export.tmp')
 
458
 
 
459
        runbzr('log')
 
460
        runbzr('log -v')
 
461
        runbzr('log -v --forward')
 
462
        runbzr('log -m', retcode=1)
 
463
        log_out = capture('log -m commit')
 
464
        assert "this is my new commit" in log_out
 
465
        assert "rename nested" not in log_out
 
466
        assert 'revision-id' not in log_out
 
467
        assert 'revision-id' in capture('log --show-ids -m commit')
 
468
 
 
469
 
 
470
        progress("file with spaces in name")
 
471
        mkdir('sub directory')
 
472
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
 
473
        runbzr('add .')
 
474
        runbzr('diff')
 
475
        runbzr('commit -m add-spaces')
 
476
        runbzr('check')
 
477
 
 
478
        runbzr('log')
 
479
        runbzr('log --forward')
 
480
 
 
481
        runbzr('info')
 
482