/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-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
 
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_revision())
 
250
        self.log('pending merges: %s', a.pending_merges())
 
251
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
252
        #        % (a.pending_merges(), b.last_revision())
 
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
        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
        
 
293
    def test_add_reports(self):
 
294
        """add command prints the names of added files."""
 
295
        b = Branch.initialize('.')
 
296
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
297
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
298
        # the ordering is not defined at the moment
 
299
        results = sorted(out.rstrip('\n').split('\n'))
 
300
        self.assertEquals(['added dir',
 
301
                           'added dir'+os.sep+'sub.txt',
 
302
                           'added top.txt',],
 
303
                          results)
 
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
        
180
312
 
181
313
 
182
314
class OldTests(ExternalBase):
183
 
    # old tests moved from ./testbzr
184
 
    def runTest(self):
 
315
    """old tests moved from ./testbzr."""
 
316
 
 
317
    def test_bzr(self):
185
318
        from os import chdir, mkdir
186
319
        from os.path import exists
187
 
        import os
188
320
 
189
321
        runbzr = self.runbzr
190
 
        backtick = self.backtick
 
322
        capture = self.capture
191
323
        progress = self.log
192
324
 
193
325
        progress("basic branch creation")
195
327
        chdir('branch1')
196
328
        runbzr('init')
197
329
 
198
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
330
        self.assertEquals(capture('root').rstrip(),
199
331
                          os.path.join(self.test_dir, 'branch1'))
200
332
 
201
333
        progress("status of new file")
204
336
        f.write('hello world!\n')
205
337
        f.close()
206
338
 
207
 
        out = backtick("bzr unknowns")
208
 
        self.assertEquals(out, 'test.txt\n')
 
339
        self.assertEquals(capture('unknowns'), 'test.txt\n')
209
340
 
210
 
        out = backtick("bzr status")
 
341
        out = capture("status")
211
342
        assert out == 'unknown:\n  test.txt\n'
212
343
 
213
 
        out = backtick("bzr status --all")
 
344
        out = capture("status --all")
214
345
        assert out == "unknown:\n  test.txt\n"
215
346
 
216
 
        out = backtick("bzr status test.txt --all")
 
347
        out = capture("status test.txt --all")
217
348
        assert out == "unknown:\n  test.txt\n"
218
349
 
219
350
        f = file('test2.txt', 'wt')
220
351
        f.write('goodbye cruel world...\n')
221
352
        f.close()
222
353
 
223
 
        out = backtick("bzr status test.txt")
 
354
        out = capture("status test.txt")
224
355
        assert out == "unknown:\n  test.txt\n"
225
356
 
226
 
        out = backtick("bzr status")
 
357
        out = capture("status")
227
358
        assert out == ("unknown:\n"
228
359
                       "  test.txt\n"
229
360
                       "  test2.txt\n")
231
362
        os.unlink('test2.txt')
232
363
 
233
364
        progress("command aliases")
234
 
        out = backtick("bzr st --all")
 
365
        out = capture("st --all")
235
366
        assert out == ("unknown:\n"
236
367
                       "  test.txt\n")
237
368
 
238
 
        out = backtick("bzr stat")
 
369
        out = capture("stat")
239
370
        assert out == ("unknown:\n"
240
371
                       "  test.txt\n")
241
372
 
245
376
        runbzr("help commands")
246
377
        runbzr("help slartibartfast", 1)
247
378
 
248
 
        out = backtick("bzr help ci")
 
379
        out = capture("help ci")
249
380
        out.index('aliases: ')
250
381
 
251
382
        progress("can't rename unversioned file")
254
385
        progress("adding a file")
255
386
 
256
387
        runbzr("add test.txt")
257
 
        assert backtick("bzr unknowns") == ''
258
 
        assert backtick("bzr status --all") == ("added:\n"
 
388
        assert capture("unknowns") == ''
 
389
        assert capture("status --all") == ("added:\n"
259
390
                                                "  test.txt\n")
260
391
 
261
392
        progress("rename newly-added file")
263
394
        assert os.path.exists("hello.txt")
264
395
        assert not os.path.exists("test.txt")
265
396
 
266
 
        assert backtick("bzr revno") == '0\n'
 
397
        assert capture("revno") == '0\n'
267
398
 
268
399
        progress("add first revision")
269
400
        runbzr(['commit', '-m', 'add first revision'])
277
408
        runbzr("add sub1")
278
409
        runbzr("rename sub1 sub2")
279
410
        runbzr("move hello.txt sub2")
280
 
        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")
281
412
 
282
413
        assert exists("sub2")
283
414
        assert exists("sub2/hello.txt")
298
429
        runbzr(['commit', '-m', 'rename nested subdirectories'])
299
430
 
300
431
        chdir('sub1/sub2')
301
 
        self.assertEquals(backtick('bzr root')[:-1],
 
432
        self.assertEquals(capture('root')[:-1],
302
433
                          os.path.join(self.test_dir, 'branch1'))
303
434
        runbzr('move ../hello.txt .')
304
435
        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')
 
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')
307
439
        runbzr(['commit', '-m', 'move to parent directory'])
308
440
        chdir('..')
309
 
        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')
310
442
 
311
443
        runbzr('move sub2/hello.txt .')
312
444
        assert exists('hello.txt')
321
453
 
322
454
        runbzr('commit -F msg.tmp')
323
455
 
324
 
        assert backtick('bzr revno') == '5\n'
 
456
        assert capture('revno') == '5\n'
325
457
        runbzr('export -r 5 export-5.tmp')
326
458
        runbzr('export export.tmp')
327
459
 
329
461
        runbzr('log -v')
330
462
        runbzr('log -v --forward')
331
463
        runbzr('log -m', retcode=1)
332
 
        log_out = backtick('bzr log -m commit')
 
464
        log_out = capture('log -m commit')
333
465
        assert "this is my new commit" in log_out
334
466
        assert "rename nested" not in log_out
335
467
        assert 'revision-id' not in log_out
336
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
468
        assert 'revision-id' in capture('log --show-ids -m commit')
337
469
 
338
470
 
339
471
        progress("file with spaces in name")
349
481
 
350
482
        runbzr('info')
351
483
 
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