~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-09-22 13:32:02 UTC
  • Revision ID: mbp@sourcefrog.net-20050922133202-347cfd35d2941dd5
- simple weave-based annotate code (not complete)

Show diffs side-by-side

added added

removed removed

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