/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

nuke duplicate test functions

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