~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-08-23 10:44:48 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050823104448-fb5d448e7a5a8ee3
relace runTest with test_foo in blackbox tests

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
29
import sys
31
 
import os
32
 
 
33
 
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
34
 
from bzrlib.branch import Branch
35
 
from bzrlib.commands import run_bzr
36
 
 
37
 
 
38
 
class ExternalBase(TestCaseInTempDir):
39
 
    def runbzr(self, args, retcode=0, backtick=False):
 
30
from bzrlib.selftest import InTempDir, BzrTestBase
 
31
 
 
32
 
 
33
class ExternalBase(InTempDir):
 
34
 
 
35
    def runbzr(self, args, retcode=0,backtick=False):
 
36
        try:
 
37
            import shutil
 
38
            from subprocess import call
 
39
        except ImportError, e:
 
40
            _need_subprocess()
 
41
            raise
 
42
 
40
43
        if isinstance(args, basestring):
41
44
            args = args.split()
42
45
 
43
46
        if backtick:
44
 
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
47
            return self.backtick(['python', self.BZRPATH,] + args,
 
48
                           retcode=retcode)
45
49
        else:
46
 
            return self.run_bzr_captured(args, retcode=retcode)
47
 
 
 
50
            return self.runcmd(['python', self.BZRPATH,] + args,
 
51
                           retcode=retcode)
48
52
 
49
53
class TestCommands(ExternalBase):
50
54
 
56
60
        self.runbzr('commit -h')
57
61
 
58
62
    def test_init_branch(self):
 
63
        import os
59
64
        self.runbzr(['init'])
60
65
 
61
66
    def test_whoami(self):
72
77
        f = file('.bzr/email', 'wt')
73
78
        f.write('Branch Identity <branch@identi.ty>')
74
79
        f.close()
75
 
        bzr_email = os.environ.get('BZREMAIL')
76
 
        if bzr_email is not None:
77
 
            del os.environ['BZREMAIL']
78
80
        whoami = self.runbzr("whoami",backtick=True)
79
81
        whoami_email = self.runbzr("whoami --email",backtick=True)
80
82
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
81
83
        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
84
 
92
85
    def test_invalid_commands(self):
93
86
        self.runbzr("pants", retcode=1)
104
97
    def test_ignore_patterns(self):
105
98
        from bzrlib.branch import Branch
106
99
        
107
 
        b = Branch.initialize('.')
 
100
        b = Branch('.', init=True)
108
101
        self.assertEquals(list(b.unknowns()), [])
109
102
 
110
103
        file('foo.tmp', 'wt').write('tmp files are ignored')
111
104
        self.assertEquals(list(b.unknowns()), [])
112
 
        assert self.capture('unknowns') == ''
 
105
        assert self.backtick('bzr unknowns') == ''
113
106
 
114
107
        file('foo.c', 'wt').write('int main() {}')
115
108
        self.assertEquals(list(b.unknowns()), ['foo.c'])
116
 
        assert self.capture('unknowns') == 'foo.c\n'
 
109
        assert self.backtick('bzr unknowns') == 'foo.c\n'
117
110
 
118
111
        self.runbzr(['add', 'foo.c'])
119
 
        assert self.capture('unknowns') == ''
 
112
        assert self.backtick('bzr unknowns') == ''
120
113
 
121
114
        # 'ignore' works when creating the .bzignore file
122
115
        file('foo.blah', 'wt').write('blah')
128
121
        # 'ignore' works when then .bzrignore file already exists
129
122
        file('garh', 'wt').write('garh')
130
123
        self.assertEquals(list(b.unknowns()), ['garh'])
131
 
        assert self.capture('unknowns') == 'garh\n'
 
124
        assert self.backtick('bzr unknowns') == 'garh\n'
132
125
        self.runbzr('ignore garh')
133
126
        self.assertEquals(list(b.unknowns()), [])
134
127
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
151
144
        self.check_file_contents('goodbye', 'qux')
152
145
        self.runbzr('revert')
153
146
        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):
 
147
        
 
148
    def skipped_test_mv_modes(self):
169
149
        """Test two modes of operation for mv"""
170
150
        from bzrlib.branch import Branch
171
 
        b = Branch.initialize('.')
 
151
        b = Branch('.', init=True)
172
152
        self.build_tree(['a', 'c', 'subdir/'])
173
 
        self.run_bzr('add', self.test_dir)
174
153
        self.run_bzr('mv', 'a', 'b')
175
154
        self.run_bzr('mv', 'b', 'subdir')
176
155
        self.run_bzr('mv', 'subdir/b', 'a')
177
 
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
156
        self.run_bzr('mv', 'a', 'b', 'subdir')
178
157
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
179
158
 
180
 
 
181
159
    def test_main_version(self):
182
160
        """Check output from version command and master option is reasonable"""
183
161
        # output is intentionally passed through to stdout so that we
193
171
        self.log(tmp_output)
194
172
        self.assertEquals(output, tmp_output)
195
173
 
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_diff(self):
215
 
        self.example_branch()
216
 
        file('hello', 'wt').write('hello world!')
217
 
        self.runbzr('commit -m fixing hello')
218
 
        output = self.runbzr('diff -r 2..3', backtick=1)
219
 
        self.assert_('\n+hello world!' in output)
220
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
221
 
        self.assert_('\n+baz' in output)
222
 
 
223
 
    def test_merge(self):
224
 
        from bzrlib.branch import Branch
225
 
        
226
 
        os.mkdir('a')
227
 
        os.chdir('a')
228
 
        self.example_branch()
229
 
        os.chdir('..')
230
 
        self.runbzr('branch a b')
231
 
        os.chdir('b')
232
 
        file('goodbye', 'wt').write('quux')
233
 
        self.runbzr(['commit',  '-m',  "more u's are always good"])
234
 
 
235
 
        os.chdir('../a')
236
 
        file('hello', 'wt').write('quuux')
237
 
        # We can't merge when there are in-tree changes
238
 
        self.runbzr('merge ../b', retcode=1)
239
 
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
240
 
        self.runbzr('merge ../b')
241
 
        self.check_file_contents('goodbye', 'quux')
242
 
        # Merging a branch pulls its revision into the tree
243
 
        a = Branch.open('.')
244
 
        b = Branch.open('../b')
245
 
        a.get_revision_xml(b.last_patch())
246
 
        self.log('pending merges: %s', a.pending_merges())
247
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
248
 
        #        % (a.pending_merges(), b.last_patch())
249
 
 
250
 
    def test_pull(self):
251
 
        """Pull changes from one branch to another."""
252
 
        os.mkdir('a')
253
 
        os.chdir('a')
254
 
 
255
 
        self.example_branch()
256
 
        self.runbzr('pull', retcode=1)
257
 
        self.runbzr('missing', retcode=1)
258
 
        self.runbzr('missing .')
259
 
        self.runbzr('missing')
260
 
        self.runbzr('pull')
261
 
        self.runbzr('pull /', retcode=1)
262
 
        self.runbzr('pull')
263
 
 
264
 
        os.chdir('..')
265
 
        self.runbzr('branch a b')
266
 
        os.chdir('b')
267
 
        self.runbzr('pull')
268
 
        self.runbzr('commit -m blah --unchanged')
269
 
        os.chdir('../a')
270
 
        a = Branch.open('.')
271
 
        b = Branch.open('../b')
272
 
        assert a.revision_history() == b.revision_history()[:-1]
273
 
        self.runbzr('pull ../b')
274
 
        assert a.revision_history() == b.revision_history()
275
 
        self.runbzr('commit -m blah2 --unchanged')
276
 
        os.chdir('../b')
277
 
        self.runbzr('commit -m blah3 --unchanged')
278
 
        self.runbzr('pull ../a', retcode=1)
279
 
        os.chdir('../a')
280
 
        self.runbzr('merge ../b')
281
 
        self.runbzr('commit -m blah4 --unchanged')
282
 
        os.chdir('../b')
283
 
        self.runbzr('pull ../a')
284
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
285
 
        
286
 
    def test_add_reports(self):
287
 
        """add command prints the names of added files."""
288
 
        b = Branch.initialize('.')
289
 
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
290
 
        out = StringIO()
291
 
        ret = self.apply_redirected(None, out, None,
292
 
                                    run_bzr,
293
 
                                    ['add'])
294
 
        self.assertEquals(ret, 0)
295
 
        # the ordering is not defined at the moment
296
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
297
 
        self.assertEquals(['added dir',
298
 
                           'added dir/sub.txt',
299
 
                           'added top.txt',],
300
 
                          results)
301
 
 
302
 
    def test_unknown_command(self):
303
 
        """Handling of unknown command."""
304
 
        out, err = self.run_bzr_captured(['fluffy-badger'],
305
 
                                         retcode=1)
306
 
        self.assertEquals(out, '')
307
 
        err.index('unknown command')
308
 
        
309
 
 
310
 
 
311
174
class OldTests(ExternalBase):
312
 
    """old tests moved from ./testbzr."""
313
 
 
 
175
    # old tests moved from ./testbzr
314
176
    def test_bzr(self):
315
177
        from os import chdir, mkdir
316
178
        from os.path import exists
 
179
        import os
317
180
 
318
181
        runbzr = self.runbzr
319
 
        capture = self.capture
 
182
        backtick = self.backtick
320
183
        progress = self.log
321
184
 
322
185
        progress("basic branch creation")
324
187
        chdir('branch1')
325
188
        runbzr('init')
326
189
 
327
 
        self.assertEquals(capture('root').rstrip(),
 
190
        self.assertEquals(backtick('bzr root').rstrip(),
328
191
                          os.path.join(self.test_dir, 'branch1'))
329
192
 
330
193
        progress("status of new file")
333
196
        f.write('hello world!\n')
334
197
        f.close()
335
198
 
336
 
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
199
        out = backtick("bzr unknowns")
 
200
        self.assertEquals(out, 'test.txt\n')
337
201
 
338
 
        out = capture("status")
 
202
        out = backtick("bzr status")
339
203
        assert out == 'unknown:\n  test.txt\n'
340
204
 
341
 
        out = capture("status --all")
 
205
        out = backtick("bzr status --all")
342
206
        assert out == "unknown:\n  test.txt\n"
343
207
 
344
 
        out = capture("status test.txt --all")
 
208
        out = backtick("bzr status test.txt --all")
345
209
        assert out == "unknown:\n  test.txt\n"
346
210
 
347
211
        f = file('test2.txt', 'wt')
348
212
        f.write('goodbye cruel world...\n')
349
213
        f.close()
350
214
 
351
 
        out = capture("status test.txt")
 
215
        out = backtick("bzr status test.txt")
352
216
        assert out == "unknown:\n  test.txt\n"
353
217
 
354
 
        out = capture("status")
 
218
        out = backtick("bzr status")
355
219
        assert out == ("unknown:\n"
356
220
                       "  test.txt\n"
357
221
                       "  test2.txt\n")
359
223
        os.unlink('test2.txt')
360
224
 
361
225
        progress("command aliases")
362
 
        out = capture("st --all")
 
226
        out = backtick("bzr st --all")
363
227
        assert out == ("unknown:\n"
364
228
                       "  test.txt\n")
365
229
 
366
 
        out = capture("stat")
 
230
        out = backtick("bzr stat")
367
231
        assert out == ("unknown:\n"
368
232
                       "  test.txt\n")
369
233
 
373
237
        runbzr("help commands")
374
238
        runbzr("help slartibartfast", 1)
375
239
 
376
 
        out = capture("help ci")
 
240
        out = backtick("bzr help ci")
377
241
        out.index('aliases: ')
378
242
 
379
243
        progress("can't rename unversioned file")
382
246
        progress("adding a file")
383
247
 
384
248
        runbzr("add test.txt")
385
 
        assert capture("unknowns") == ''
386
 
        assert capture("status --all") == ("added:\n"
 
249
        assert backtick("bzr unknowns") == ''
 
250
        assert backtick("bzr status --all") == ("added:\n"
387
251
                                                "  test.txt\n")
388
252
 
389
253
        progress("rename newly-added file")
391
255
        assert os.path.exists("hello.txt")
392
256
        assert not os.path.exists("test.txt")
393
257
 
394
 
        assert capture("revno") == '0\n'
 
258
        assert backtick("bzr revno") == '0\n'
395
259
 
396
260
        progress("add first revision")
397
261
        runbzr(['commit', '-m', 'add first revision'])
405
269
        runbzr("add sub1")
406
270
        runbzr("rename sub1 sub2")
407
271
        runbzr("move hello.txt sub2")
408
 
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
272
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
409
273
 
410
274
        assert exists("sub2")
411
275
        assert exists("sub2/hello.txt")
426
290
        runbzr(['commit', '-m', 'rename nested subdirectories'])
427
291
 
428
292
        chdir('sub1/sub2')
429
 
        self.assertEquals(capture('root')[:-1],
 
293
        self.assertEquals(backtick('bzr root')[:-1],
430
294
                          os.path.join(self.test_dir, 'branch1'))
431
295
        runbzr('move ../hello.txt .')
432
296
        assert exists('./hello.txt')
433
 
        self.assertEquals(capture('relpath hello.txt'),
434
 
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
435
 
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
297
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
298
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
436
299
        runbzr(['commit', '-m', 'move to parent directory'])
437
300
        chdir('..')
438
 
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
301
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
439
302
 
440
303
        runbzr('move sub2/hello.txt .')
441
304
        assert exists('hello.txt')
450
313
 
451
314
        runbzr('commit -F msg.tmp')
452
315
 
453
 
        assert capture('revno') == '5\n'
 
316
        assert backtick('bzr revno') == '5\n'
454
317
        runbzr('export -r 5 export-5.tmp')
455
318
        runbzr('export export.tmp')
456
319
 
458
321
        runbzr('log -v')
459
322
        runbzr('log -v --forward')
460
323
        runbzr('log -m', retcode=1)
461
 
        log_out = capture('log -m commit')
 
324
        log_out = backtick('bzr log -m commit')
462
325
        assert "this is my new commit" in log_out
463
326
        assert "rename nested" not in log_out
464
327
        assert 'revision-id' not in log_out
465
 
        assert 'revision-id' in capture('log --show-ids -m commit')
 
328
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
466
329
 
467
330
 
468
331
        progress("file with spaces in name")
478
341
 
479
342
        runbzr('info')
480
343
 
 
344