/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

  • Committer: Robert Collins
  • Date: 2005-09-26 08:56:15 UTC
  • mto: (1092.3.4)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: robertc@robertcollins.net-20050926085615-99b8fb35f41b541d
massive patch from Alexander Belchenko - many PEP8 fixes, removes unused function uuid

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