/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-09-27 07:24:40 UTC
  • mfrom: (1185.1.41)
  • Revision ID: robertc@robertcollins.net-20050927072440-1bf4d99c3e1db5b3
pair programming worx... merge integration and weave

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 os
 
31
import sys
 
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', 'rU').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', 'rU').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_revision())
 
250
        self.log('pending merges: %s', a.pending_merges())
 
251
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
252
        #        % (a.pending_merges(), b.last_revision())
 
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
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
286
##        os.chdir('../a')
 
287
##        self.runbzr('merge ../b')
 
288
##        self.runbzr('commit -m blah4 --unchanged')
 
289
##        os.chdir('../b/subdir')
 
290
##        self.runbzr('pull ../../a')
 
291
##        assert a.revision_history()[-1] == b.revision_history()[-1]
 
292
        
 
293
    def test_add_reports(self):
 
294
        """add command prints the names of added files."""
 
295
        b = Branch.initialize('.')
 
296
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
297
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
298
        # the ordering is not defined at the moment
 
299
        results = sorted(out.rstrip('\n').split('\n'))
 
300
        self.assertEquals(['added dir',
 
301
                           'added dir'+os.sep+'sub.txt',
 
302
                           'added top.txt',],
 
303
                          results)
 
304
 
 
305
    def test_unknown_command(self):
 
306
        """Handling of unknown command."""
 
307
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
308
                                         retcode=1)
 
309
        self.assertEquals(out, '')
 
310
        err.index('unknown command')
 
311
        
 
312
 
 
313
 
 
314
class OldTests(ExternalBase):
 
315
    """old tests moved from ./testbzr."""
 
316
 
 
317
    def test_bzr(self):
 
318
        from os import chdir, mkdir
 
319
        from os.path import exists
 
320
 
 
321
        runbzr = self.runbzr
 
322
        capture = self.capture
 
323
        progress = self.log
 
324
 
 
325
        progress("basic branch creation")
 
326
        mkdir('branch1')
 
327
        chdir('branch1')
 
328
        runbzr('init')
 
329
 
 
330
        self.assertEquals(capture('root').rstrip(),
 
331
                          os.path.join(self.test_dir, 'branch1'))
 
332
 
 
333
        progress("status of new file")
 
334
 
 
335
        f = file('test.txt', 'wt')
 
336
        f.write('hello world!\n')
 
337
        f.close()
 
338
 
 
339
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
340
 
 
341
        out = capture("status")
 
342
        assert out == 'unknown:\n  test.txt\n'
 
343
 
 
344
        out = capture("status --all")
 
345
        assert out == "unknown:\n  test.txt\n"
 
346
 
 
347
        out = capture("status test.txt --all")
 
348
        assert out == "unknown:\n  test.txt\n"
 
349
 
 
350
        f = file('test2.txt', 'wt')
 
351
        f.write('goodbye cruel world...\n')
 
352
        f.close()
 
353
 
 
354
        out = capture("status test.txt")
 
355
        assert out == "unknown:\n  test.txt\n"
 
356
 
 
357
        out = capture("status")
 
358
        assert out == ("unknown:\n"
 
359
                       "  test.txt\n"
 
360
                       "  test2.txt\n")
 
361
 
 
362
        os.unlink('test2.txt')
 
363
 
 
364
        progress("command aliases")
 
365
        out = capture("st --all")
 
366
        assert out == ("unknown:\n"
 
367
                       "  test.txt\n")
 
368
 
 
369
        out = capture("stat")
 
370
        assert out == ("unknown:\n"
 
371
                       "  test.txt\n")
 
372
 
 
373
        progress("command help")
 
374
        runbzr("help st")
 
375
        runbzr("help")
 
376
        runbzr("help commands")
 
377
        runbzr("help slartibartfast", 1)
 
378
 
 
379
        out = capture("help ci")
 
380
        out.index('aliases: ')
 
381
 
 
382
        progress("can't rename unversioned file")
 
383
        runbzr("rename test.txt new-test.txt", 1)
 
384
 
 
385
        progress("adding a file")
 
386
 
 
387
        runbzr("add test.txt")
 
388
        assert capture("unknowns") == ''
 
389
        assert capture("status --all") == ("added:\n"
 
390
                                                "  test.txt\n")
 
391
 
 
392
        progress("rename newly-added file")
 
393
        runbzr("rename test.txt hello.txt")
 
394
        assert os.path.exists("hello.txt")
 
395
        assert not os.path.exists("test.txt")
 
396
 
 
397
        assert capture("revno") == '0\n'
 
398
 
 
399
        progress("add first revision")
 
400
        runbzr(['commit', '-m', 'add first revision'])
 
401
 
 
402
        progress("more complex renames")
 
403
        os.mkdir("sub1")
 
404
        runbzr("rename hello.txt sub1", 1)
 
405
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
406
        runbzr("move hello.txt sub1", 1)
 
407
 
 
408
        runbzr("add sub1")
 
409
        runbzr("rename sub1 sub2")
 
410
        runbzr("move hello.txt sub2")
 
411
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
412
 
 
413
        assert exists("sub2")
 
414
        assert exists("sub2/hello.txt")
 
415
        assert not exists("sub1")
 
416
        assert not exists("hello.txt")
 
417
 
 
418
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
419
 
 
420
        mkdir("sub1")
 
421
        runbzr('add sub1')
 
422
        runbzr('move sub2/hello.txt sub1')
 
423
        assert not exists('sub2/hello.txt')
 
424
        assert exists('sub1/hello.txt')
 
425
        runbzr('move sub2 sub1')
 
426
        assert not exists('sub2')
 
427
        assert exists('sub1/sub2')
 
428
 
 
429
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
430
 
 
431
        chdir('sub1/sub2')
 
432
        self.assertEquals(capture('root')[:-1],
 
433
                          os.path.join(self.test_dir, 'branch1'))
 
434
        runbzr('move ../hello.txt .')
 
435
        assert exists('./hello.txt')
 
436
        self.assertEquals(capture('relpath hello.txt'),
 
437
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
438
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
439
        runbzr(['commit', '-m', 'move to parent directory'])
 
440
        chdir('..')
 
441
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
442
 
 
443
        runbzr('move sub2/hello.txt .')
 
444
        assert exists('hello.txt')
 
445
 
 
446
        f = file('hello.txt', 'wt')
 
447
        f.write('some nice new content\n')
 
448
        f.close()
 
449
 
 
450
        f = file('msg.tmp', 'wt')
 
451
        f.write('this is my new commit\n')
 
452
        f.close()
 
453
 
 
454
        runbzr('commit -F msg.tmp')
 
455
 
 
456
        assert capture('revno') == '5\n'
 
457
        runbzr('export -r 5 export-5.tmp')
 
458
        runbzr('export export.tmp')
 
459
 
 
460
        runbzr('log')
 
461
        runbzr('log -v')
 
462
        runbzr('log -v --forward')
 
463
        runbzr('log -m', retcode=1)
 
464
        log_out = capture('log -m commit')
 
465
        assert "this is my new commit" in log_out
 
466
        assert "rename nested" not in log_out
 
467
        assert 'revision-id' not in log_out
 
468
        assert 'revision-id' in capture('log --show-ids -m commit')
 
469
 
 
470
 
 
471
        progress("file with spaces in name")
 
472
        mkdir('sub directory')
 
473
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
 
474
        runbzr('add .')
 
475
        runbzr('diff')
 
476
        runbzr('commit -m add-spaces')
 
477
        runbzr('check')
 
478
 
 
479
        runbzr('log')
 
480
        runbzr('log --forward')
 
481
 
 
482
        runbzr('info')
 
483