← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-09-28 09:35:50 UTC
  • mfrom: (1185.1.47)
  • Revision ID: robertc@robertcollins.net-20050928093550-3ca194dfaffc79f1
merge from integration

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
26
26
it's normally invoked.
27
27
"""
28
28
 
 
29
from cStringIO import StringIO
 
30
import os
 
31
import shutil
29
32
import sys
30
33
 
31
34
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
32
35
from bzrlib.branch import Branch
33
 
from bzrlib.commands import run_bzr
34
36
 
35
37
 
36
38
class ExternalBase(TestCaseInTempDir):
37
 
    def runbzr(self, args, retcode=0,backtick=False):
 
39
 
 
40
    def runbzr(self, args, retcode=0, backtick=False):
38
41
        if isinstance(args, basestring):
39
42
            args = args.split()
40
43
 
41
44
        if backtick:
42
 
            return self.backtick(['python', self.BZRPATH,] + args,
43
 
                           retcode=retcode)
 
45
            return self.run_bzr_captured(args, retcode=retcode)[0]
44
46
        else:
45
 
            return self.runcmd(['python', self.BZRPATH,] + args,
46
 
                           retcode=retcode)
 
47
            return self.run_bzr_captured(args, retcode=retcode)
47
48
 
48
49
 
49
50
class TestCommands(ExternalBase):
72
73
        f = file('.bzr/email', 'wt')
73
74
        f.write('Branch Identity <branch@identi.ty>')
74
75
        f.close()
 
76
        bzr_email = os.environ.get('BZREMAIL')
 
77
        if bzr_email is not None:
 
78
            del os.environ['BZREMAIL']
75
79
        whoami = self.runbzr("whoami",backtick=True)
76
80
        whoami_email = self.runbzr("whoami --email",backtick=True)
77
81
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
78
82
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
83
        # Verify that the environment variable overrides the value 
 
84
        # in the file
 
85
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
86
        whoami = self.runbzr("whoami",backtick=True)
 
87
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
88
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
89
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
90
        if bzr_email is not None:
 
91
            os.environ['BZREMAIL'] = bzr_email
79
92
 
80
93
    def test_invalid_commands(self):
81
94
        self.runbzr("pants", retcode=1)
92
105
    def test_ignore_patterns(self):
93
106
        from bzrlib.branch import Branch
94
107
        
95
 
        b = Branch('.', init=True)
 
108
        b = Branch.initialize('.')
96
109
        self.assertEquals(list(b.unknowns()), [])
97
110
 
98
111
        file('foo.tmp', 'wt').write('tmp files are ignored')
99
112
        self.assertEquals(list(b.unknowns()), [])
100
 
        assert self.backtick('bzr unknowns') == ''
 
113
        assert self.capture('unknowns') == ''
101
114
 
102
115
        file('foo.c', 'wt').write('int main() {}')
103
116
        self.assertEquals(list(b.unknowns()), ['foo.c'])
104
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
117
        assert self.capture('unknowns') == 'foo.c\n'
105
118
 
106
119
        self.runbzr(['add', 'foo.c'])
107
 
        assert self.backtick('bzr unknowns') == ''
 
120
        assert self.capture('unknowns') == ''
108
121
 
109
122
        # 'ignore' works when creating the .bzignore file
110
123
        file('foo.blah', 'wt').write('blah')
111
124
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
112
125
        self.runbzr('ignore *.blah')
113
126
        self.assertEquals(list(b.unknowns()), [])
114
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
127
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
115
128
 
116
129
        # 'ignore' works when then .bzrignore file already exists
117
130
        file('garh', 'wt').write('garh')
118
131
        self.assertEquals(list(b.unknowns()), ['garh'])
119
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
132
        assert self.capture('unknowns') == 'garh\n'
120
133
        self.runbzr('ignore garh')
121
134
        self.assertEquals(list(b.unknowns()), [])
122
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
123
136
 
124
137
    def test_revert(self):
125
 
        import os
126
138
        self.runbzr('init')
127
139
 
128
140
        file('hello', 'wt').write('foo')
147
159
        os.rmdir('revertdir')
148
160
        self.runbzr('revert')
149
161
 
150
 
    def skipped_test_mv_modes(self):
 
162
        file('hello', 'wt').write('xyz')
 
163
        self.runbzr('commit -m xyz hello')
 
164
        self.runbzr('revert -r 1 hello')
 
165
        self.check_file_contents('hello', 'foo')
 
166
        self.runbzr('revert hello')
 
167
        self.check_file_contents('hello', 'xyz')
 
168
        os.chdir('revertdir')
 
169
        self.runbzr('revert')
 
170
        os.chdir('..')
 
171
 
 
172
 
 
173
    def test_mv_modes(self):
151
174
        """Test two modes of operation for mv"""
152
175
        from bzrlib.branch import Branch
153
 
        b = Branch('.', init=True)
 
176
        b = Branch.initialize('.')
154
177
        self.build_tree(['a', 'c', 'subdir/'])
155
 
        self.run_bzr('mv', 'a', 'b')
156
 
        self.run_bzr('mv', 'b', 'subdir')
157
 
        self.run_bzr('mv', 'subdir/b', 'a')
158
 
        self.run_bzr('mv', 'a', 'b', 'subdir')
159
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
178
        self.run_bzr_captured(['add', self.test_dir])
 
179
        self.run_bzr_captured(['mv', 'a', 'b'])
 
180
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
181
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
182
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
183
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
184
 
160
185
 
161
186
    def test_main_version(self):
162
187
        """Check output from version command and master option is reasonable"""
182
207
        test.runbzr('add goodbye')
183
208
        test.runbzr('commit -m setup goodbye')
184
209
 
185
 
    def test_revert(self):
186
 
        self.example_branch()
187
 
        file('hello', 'wt').write('bar')
188
 
        file('goodbye', 'wt').write('qux')
189
 
        self.runbzr('revert hello')
190
 
        self.check_file_contents('hello', 'foo')
191
 
        self.check_file_contents('goodbye', 'qux')
192
 
        self.runbzr('revert')
193
 
        self.check_file_contents('goodbye', 'baz')
 
210
    def test_diff(self):
 
211
        self.example_branch()
 
212
        file('hello', 'wt').write('hello world!')
 
213
        self.runbzr('commit -m fixing hello')
 
214
        output = self.runbzr('diff -r 2..3', backtick=1)
 
215
        self.assert_('\n+hello world!' in output)
 
216
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
217
        self.assert_('\n+baz' in output)
 
218
 
 
219
    def test_branch(self):
 
220
        """Branch from one branch to another."""
 
221
        os.mkdir('a')
 
222
        os.chdir('a')
 
223
        self.example_branch()
 
224
        os.chdir('..')
 
225
        self.runbzr('branch a b')
 
226
        self.runbzr('branch a c -r 1')
 
227
        os.chdir('b')
 
228
        self.runbzr('commit -m foo --unchanged')
 
229
        os.chdir('..')
 
230
        shutil.rmtree('a/.bzr/revision-store')
 
231
        # naughty - abstraction violations RBC 20050928  
 
232
        shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
233
        shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
234
        self.runbzr('branch a d --basis b')
194
235
 
195
236
    def test_merge(self):
196
237
        from bzrlib.branch import Branch
197
 
        import os
198
238
        
199
239
        os.mkdir('a')
200
240
        os.chdir('a')
201
 
 
202
241
        self.example_branch()
203
242
        os.chdir('..')
204
243
        self.runbzr('branch a b')
214
253
        self.runbzr('merge ../b')
215
254
        self.check_file_contents('goodbye', 'quux')
216
255
        # 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
 
 
 
256
        a = Branch.open('.')
 
257
        b = Branch.open('../b')
 
258
        a.get_revision_xml(b.last_revision())
221
259
        self.log('pending merges: %s', a.pending_merges())
222
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
223
 
        #        % (a.pending_merges(), b.last_patch())
224
 
 
225
 
 
 
260
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
261
        #        % (a.pending_merges(), b.last_revision())
 
262
 
 
263
    def test_pull(self):
 
264
        """Pull changes from one branch to another."""
 
265
        os.mkdir('a')
 
266
        os.chdir('a')
 
267
 
 
268
        self.example_branch()
 
269
        self.runbzr('pull', retcode=1)
 
270
        self.runbzr('missing', retcode=1)
 
271
        self.runbzr('missing .')
 
272
        self.runbzr('missing')
 
273
        self.runbzr('pull')
 
274
        self.runbzr('pull /', retcode=1)
 
275
        self.runbzr('pull')
 
276
 
 
277
        os.chdir('..')
 
278
        self.runbzr('branch a b')
 
279
        os.chdir('b')
 
280
        self.runbzr('pull')
 
281
        os.mkdir('subdir')
 
282
        self.runbzr('add subdir')
 
283
        self.runbzr('commit -m blah --unchanged')
 
284
        os.chdir('../a')
 
285
        a = Branch.open('.')
 
286
        b = Branch.open('../b')
 
287
        assert a.revision_history() == b.revision_history()[:-1]
 
288
        self.runbzr('pull ../b')
 
289
        assert a.revision_history() == b.revision_history()
 
290
        self.runbzr('commit -m blah2 --unchanged')
 
291
        os.chdir('../b')
 
292
        self.runbzr('commit -m blah3 --unchanged')
 
293
        self.runbzr('pull ../a', retcode=1)
 
294
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
295
        return
 
296
        os.chdir('../a')
 
297
        self.runbzr('merge ../b')
 
298
        self.runbzr('commit -m blah4 --unchanged')
 
299
        os.chdir('../b/subdir')
 
300
        self.runbzr('pull ../../a')
 
301
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
302
        self.runbzr('commit -m blah5 --unchanged')
 
303
        self.runbzr('commit -m blah6 --unchanged')
 
304
        os.chdir('..')
 
305
        self.runbzr('pull ../a')
 
306
        os.chdir('../a')
 
307
        self.runbzr('commit -m blah7 --unchanged')
 
308
        self.runbzr('merge ../b')
 
309
        self.runbzr('commit -m blah8 --unchanged')
 
310
        self.runbzr('pull ../b')
 
311
        self.runbzr('pull ../b')
 
312
        
226
313
    def test_add_reports(self):
227
314
        """add command prints the names of added files."""
228
 
        b = Branch('.', init=True)
 
315
        b = Branch.initialize('.')
229
316
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
230
 
 
231
 
        from cStringIO import StringIO
232
 
        out = StringIO()
233
 
 
234
 
        ret = self.apply_redirected(None, out, None,
235
 
                                    run_bzr,
236
 
                                    ['add'])
237
 
        self.assertEquals(ret, 0)
238
 
 
 
317
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
318
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
319
        results = sorted(out.rstrip('\n').split('\n'))
241
320
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
321
                           'added dir'+os.sep+'sub.txt',
243
322
                           'added top.txt',],
244
323
                          results)
245
324
 
 
325
    def test_unknown_command(self):
 
326
        """Handling of unknown command."""
 
327
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
328
                                         retcode=1)
 
329
        self.assertEquals(out, '')
 
330
        err.index('unknown command')
 
331
        
 
332
 
246
333
 
247
334
class OldTests(ExternalBase):
248
335
    """old tests moved from ./testbzr."""
250
337
    def test_bzr(self):
251
338
        from os import chdir, mkdir
252
339
        from os.path import exists
253
 
        import os
254
340
 
255
341
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
342
        capture = self.capture
257
343
        progress = self.log
258
344
 
259
345
        progress("basic branch creation")
261
347
        chdir('branch1')
262
348
        runbzr('init')
263
349
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
350
        self.assertEquals(capture('root').rstrip(),
265
351
                          os.path.join(self.test_dir, 'branch1'))
266
352
 
267
353
        progress("status of new file")
270
356
        f.write('hello world!\n')
271
357
        f.close()
272
358
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
 
359
        self.assertEquals(capture('unknowns'), 'test.txt\n')
275
360
 
276
 
        out = backtick("bzr status")
 
361
        out = capture("status")
277
362
        assert out == 'unknown:\n  test.txt\n'
278
363
 
279
 
        out = backtick("bzr status --all")
 
364
        out = capture("status --all")
280
365
        assert out == "unknown:\n  test.txt\n"
281
366
 
282
 
        out = backtick("bzr status test.txt --all")
 
367
        out = capture("status test.txt --all")
283
368
        assert out == "unknown:\n  test.txt\n"
284
369
 
285
370
        f = file('test2.txt', 'wt')
286
371
        f.write('goodbye cruel world...\n')
287
372
        f.close()
288
373
 
289
 
        out = backtick("bzr status test.txt")
 
374
        out = capture("status test.txt")
290
375
        assert out == "unknown:\n  test.txt\n"
291
376
 
292
 
        out = backtick("bzr status")
 
377
        out = capture("status")
293
378
        assert out == ("unknown:\n"
294
379
                       "  test.txt\n"
295
380
                       "  test2.txt\n")
297
382
        os.unlink('test2.txt')
298
383
 
299
384
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
 
385
        out = capture("st --all")
301
386
        assert out == ("unknown:\n"
302
387
                       "  test.txt\n")
303
388
 
304
 
        out = backtick("bzr stat")
 
389
        out = capture("stat")
305
390
        assert out == ("unknown:\n"
306
391
                       "  test.txt\n")
307
392
 
311
396
        runbzr("help commands")
312
397
        runbzr("help slartibartfast", 1)
313
398
 
314
 
        out = backtick("bzr help ci")
 
399
        out = capture("help ci")
315
400
        out.index('aliases: ')
316
401
 
317
402
        progress("can't rename unversioned file")
320
405
        progress("adding a file")
321
406
 
322
407
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
 
408
        assert capture("unknowns") == ''
 
409
        assert capture("status --all") == ("added:\n"
325
410
                                                "  test.txt\n")
326
411
 
327
412
        progress("rename newly-added file")
329
414
        assert os.path.exists("hello.txt")
330
415
        assert not os.path.exists("test.txt")
331
416
 
332
 
        assert backtick("bzr revno") == '0\n'
 
417
        assert capture("revno") == '0\n'
333
418
 
334
419
        progress("add first revision")
335
420
        runbzr(['commit', '-m', 'add first revision'])
343
428
        runbzr("add sub1")
344
429
        runbzr("rename sub1 sub2")
345
430
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
431
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
347
432
 
348
433
        assert exists("sub2")
349
434
        assert exists("sub2/hello.txt")
364
449
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
450
 
366
451
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
452
        self.assertEquals(capture('root')[:-1],
368
453
                          os.path.join(self.test_dir, 'branch1'))
369
454
        runbzr('move ../hello.txt .')
370
455
        assert exists('./hello.txt')
371
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
372
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
456
        self.assertEquals(capture('relpath hello.txt'),
 
457
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
458
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
373
459
        runbzr(['commit', '-m', 'move to parent directory'])
374
460
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
461
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
376
462
 
377
463
        runbzr('move sub2/hello.txt .')
378
464
        assert exists('hello.txt')
387
473
 
388
474
        runbzr('commit -F msg.tmp')
389
475
 
390
 
        assert backtick('bzr revno') == '5\n'
 
476
        assert capture('revno') == '5\n'
391
477
        runbzr('export -r 5 export-5.tmp')
392
478
        runbzr('export export.tmp')
393
479
 
395
481
        runbzr('log -v')
396
482
        runbzr('log -v --forward')
397
483
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
 
484
        log_out = capture('log -m commit')
399
485
        assert "this is my new commit" in log_out
400
486
        assert "rename nested" not in log_out
401
487
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
488
        assert 'revision-id' in capture('log --show-ids -m commit')
403
489
 
404
490
 
405
491
        progress("file with spaces in name")