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