~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-10-16 23:53:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1459.
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051016235302-818de607403e1c6e
test that the presence of a signature does not make a missing base file magically appear present

Show diffs side-by-side

added added

removed removed

Lines of Context:
19
19
"""Black-box tests for bzr.
20
20
 
21
21
These check that it behaves properly when it's invoked through the regular
22
 
command-line interface.
23
 
 
24
 
This always reinvokes bzr through a new Python interpreter, which is a
25
 
bit inefficient but arguably tests in a way more representative of how
26
 
it's normally invoked.
 
22
command-line interface. This doesn't actually run a new interpreter but 
 
23
rather starts again from the run_bzr function.
27
24
"""
28
25
 
29
 
# this code was previously in testbzr
30
 
 
31
 
from unittest import TestCase
32
 
from bzrlib.selftest import TestBase, InTempDir
33
 
 
34
 
 
35
 
 
36
 
class ExternalBase(InTempDir):
37
 
    def runbzr(self, args, retcode=0):
38
 
        try:
39
 
            import shutil
40
 
            from subprocess import call
41
 
        except ImportError, e:
42
 
            _need_subprocess()
43
 
            raise
44
 
 
 
26
 
 
27
from cStringIO import StringIO
 
28
import os
 
29
import shutil
 
30
import sys
 
31
import os
 
32
 
 
33
from bzrlib.branch import Branch
 
34
from bzrlib.clone import copy_branch
 
35
from bzrlib.errors import BzrCommandError
 
36
from bzrlib.osutils import has_symlinks
 
37
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
38
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
39
 
 
40
 
 
41
class ExternalBase(TestCaseInTempDir):
 
42
 
 
43
    def runbzr(self, args, retcode=0, backtick=False):
45
44
        if isinstance(args, basestring):
46
45
            args = args.split()
47
 
            
48
 
        return self.runcmd(['python', self.BZRPATH,] + args,
49
 
                           retcode=retcode)
50
 
 
51
 
 
52
 
 
53
 
class TestVersion(ExternalBase):
54
 
    def runTest(self):
55
 
        # output is intentionally passed through to stdout so that we
56
 
        # can see the version being tested
57
 
        self.runbzr(['version'])
58
 
 
59
 
 
60
 
 
61
 
class HelpCommands(ExternalBase):
62
 
    def runTest(self):
 
46
 
 
47
        if backtick:
 
48
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
49
        else:
 
50
            return self.run_bzr_captured(args, retcode=retcode)
 
51
 
 
52
 
 
53
class TestCommands(ExternalBase):
 
54
 
 
55
    def test_help_commands(self):
63
56
        self.runbzr('--help')
64
57
        self.runbzr('help')
65
58
        self.runbzr('help commands')
66
59
        self.runbzr('help help')
67
60
        self.runbzr('commit -h')
68
61
 
69
 
 
70
 
class InitBranch(ExternalBase):
71
 
    def runTest(self):
72
 
        import os
 
62
    def test_init_branch(self):
73
63
        self.runbzr(['init'])
74
64
 
75
 
 
76
 
 
77
 
class UserIdentity(ExternalBase):
78
 
    def runTest(self):
 
65
    def test_whoami(self):
79
66
        # this should always identify something, if only "john@localhost"
80
67
        self.runbzr("whoami")
81
68
        self.runbzr("whoami --email")
82
 
        self.assertEquals(self.backtick("bzr whoami --email").count('@'),
83
 
                          1)
84
 
 
85
 
 
86
 
class InvalidCommands(ExternalBase):
87
 
    def runTest(self):
 
69
 
 
70
        self.assertEquals(self.runbzr("whoami --email",
 
71
                                      backtick=True).count('@'), 1)
 
72
        
 
73
    def test_whoami_branch(self):
 
74
        """branch specific user identity works."""
 
75
        self.runbzr('init')
 
76
        f = file('.bzr/email', 'wt')
 
77
        f.write('Branch Identity <branch@identi.ty>')
 
78
        f.close()
 
79
        bzr_email = os.environ.get('BZREMAIL')
 
80
        if bzr_email is not None:
 
81
            del os.environ['BZREMAIL']
 
82
        whoami = self.runbzr("whoami",backtick=True)
 
83
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
84
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
85
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
86
        # Verify that the environment variable overrides the value 
 
87
        # in the file
 
88
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
89
        whoami = self.runbzr("whoami",backtick=True)
 
90
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
91
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
92
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
93
        if bzr_email is not None:
 
94
            os.environ['BZREMAIL'] = bzr_email
 
95
 
 
96
    def test_invalid_commands(self):
88
97
        self.runbzr("pants", retcode=1)
89
98
        self.runbzr("--pants off", retcode=1)
90
99
        self.runbzr("diff --message foo", retcode=1)
91
100
 
92
 
 
93
 
 
94
 
class EmptyCommit(ExternalBase):
95
 
    def runTest(self):
 
101
    def test_empty_commit(self):
96
102
        self.runbzr("init")
97
103
        self.build_tree(['hello.txt'])
98
104
        self.runbzr("commit -m empty", retcode=1)
99
105
        self.runbzr("add hello.txt")
100
106
        self.runbzr("commit -m added")
101
107
 
102
 
 
103
 
 
104
 
class IgnorePatterns(ExternalBase):
105
 
    def runTest(self):
 
108
    def test_empty_commit_message(self):
 
109
        self.runbzr("init")
 
110
        file('foo.c', 'wt').write('int main() {}')
 
111
        self.runbzr(['add', 'foo.c'])
 
112
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
113
 
 
114
    def test_ignore_patterns(self):
106
115
        from bzrlib.branch import Branch
107
116
        
108
 
        b = Branch('.', init=True)
 
117
        b = Branch.initialize('.')
109
118
        self.assertEquals(list(b.unknowns()), [])
110
119
 
111
120
        file('foo.tmp', 'wt').write('tmp files are ignored')
112
121
        self.assertEquals(list(b.unknowns()), [])
113
 
        assert self.backtick('bzr unknowns') == ''
 
122
        assert self.capture('unknowns') == ''
114
123
 
115
124
        file('foo.c', 'wt').write('int main() {}')
116
125
        self.assertEquals(list(b.unknowns()), ['foo.c'])
117
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
126
        assert self.capture('unknowns') == 'foo.c\n'
118
127
 
119
128
        self.runbzr(['add', 'foo.c'])
120
 
        assert self.backtick('bzr unknowns') == ''
 
129
        assert self.capture('unknowns') == ''
121
130
 
122
131
        # 'ignore' works when creating the .bzignore file
123
132
        file('foo.blah', 'wt').write('blah')
124
133
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
125
134
        self.runbzr('ignore *.blah')
126
135
        self.assertEquals(list(b.unknowns()), [])
127
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
136
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
128
137
 
129
138
        # 'ignore' works when then .bzrignore file already exists
130
139
        file('garh', 'wt').write('garh')
131
140
        self.assertEquals(list(b.unknowns()), ['garh'])
132
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
141
        assert self.capture('unknowns') == 'garh\n'
133
142
        self.runbzr('ignore garh')
134
143
        self.assertEquals(list(b.unknowns()), [])
135
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
136
 
        
137
 
 
 
144
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
145
 
 
146
    def test_revert(self):
 
147
        self.runbzr('init')
 
148
 
 
149
        file('hello', 'wt').write('foo')
 
150
        self.runbzr('add hello')
 
151
        self.runbzr('commit -m setup hello')
 
152
 
 
153
        file('goodbye', 'wt').write('baz')
 
154
        self.runbzr('add goodbye')
 
155
        self.runbzr('commit -m setup goodbye')
 
156
 
 
157
        file('hello', 'wt').write('bar')
 
158
        file('goodbye', 'wt').write('qux')
 
159
        self.runbzr('revert hello')
 
160
        self.check_file_contents('hello', 'foo')
 
161
        self.check_file_contents('goodbye', 'qux')
 
162
        self.runbzr('revert')
 
163
        self.check_file_contents('goodbye', 'baz')
 
164
 
 
165
        os.mkdir('revertdir')
 
166
        self.runbzr('add revertdir')
 
167
        self.runbzr('commit -m f')
 
168
        os.rmdir('revertdir')
 
169
        self.runbzr('revert')
 
170
 
 
171
        os.symlink('/unlikely/to/exist', 'symlink')
 
172
        self.runbzr('add symlink')
 
173
        self.runbzr('commit -m f')
 
174
        os.unlink('symlink')
 
175
        self.runbzr('revert')
 
176
        self.failUnlessExists('symlink')
 
177
        os.unlink('symlink')
 
178
        os.symlink('a-different-path', 'symlink')
 
179
        self.runbzr('revert')
 
180
        self.assertEqual('/unlikely/to/exist',
 
181
                         os.readlink('symlink'))
 
182
        
 
183
        file('hello', 'wt').write('xyz')
 
184
        self.runbzr('commit -m xyz hello')
 
185
        self.runbzr('revert -r 1 hello')
 
186
        self.check_file_contents('hello', 'foo')
 
187
        self.runbzr('revert hello')
 
188
        self.check_file_contents('hello', 'xyz')
 
189
        os.chdir('revertdir')
 
190
        self.runbzr('revert')
 
191
        os.chdir('..')
 
192
 
 
193
 
 
194
    def test_mv_modes(self):
 
195
        """Test two modes of operation for mv"""
 
196
        from bzrlib.branch import Branch
 
197
        b = Branch.initialize('.')
 
198
        self.build_tree(['a', 'c', 'subdir/'])
 
199
        self.run_bzr_captured(['add', self.test_dir])
 
200
        self.run_bzr_captured(['mv', 'a', 'b'])
 
201
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
202
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
203
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
204
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
205
 
 
206
    def test_main_version(self):
 
207
        """Check output from version command and master option is reasonable"""
 
208
        # output is intentionally passed through to stdout so that we
 
209
        # can see the version being tested
 
210
        output = self.runbzr('version', backtick=1)
 
211
        self.log('bzr version output:')
 
212
        self.log(output)
 
213
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
214
        self.assertNotEqual(output.index('Canonical'), -1)
 
215
        # make sure --version is consistent
 
216
        tmp_output = self.runbzr('--version', backtick=1)
 
217
        self.log('bzr --version output:')
 
218
        self.log(tmp_output)
 
219
        self.assertEquals(output, tmp_output)
 
220
 
 
221
    def example_branch(test):
 
222
        test.runbzr('init')
 
223
        file('hello', 'wt').write('foo')
 
224
        test.runbzr('add hello')
 
225
        test.runbzr('commit -m setup hello')
 
226
        file('goodbye', 'wt').write('baz')
 
227
        test.runbzr('add goodbye')
 
228
        test.runbzr('commit -m setup goodbye')
 
229
 
 
230
    def test_export(self):
 
231
        os.mkdir('branch')
 
232
        os.chdir('branch')
 
233
        self.example_branch()
 
234
        self.runbzr('export ../latest')
 
235
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
236
        self.runbzr('export ../first -r 1')
 
237
        assert not os.path.exists('../first/goodbye')
 
238
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
239
        self.runbzr('export ../first.gz -r 1')
 
240
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
241
        self.runbzr('export ../first.bz2 -r 1')
 
242
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
243
        self.runbzr('export ../first.tar -r 1')
 
244
        assert os.path.isfile('../first.tar')
 
245
        from tarfile import TarFile
 
246
        tf = TarFile('../first.tar')
 
247
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
248
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
249
        self.runbzr('export ../first.tar.gz -r 1')
 
250
        assert os.path.isfile('../first.tar.gz')
 
251
        self.runbzr('export ../first.tbz2 -r 1')
 
252
        assert os.path.isfile('../first.tbz2')
 
253
        self.runbzr('export ../first.tar.bz2 -r 1')
 
254
        assert os.path.isfile('../first.tar.bz2')
 
255
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
256
        assert os.path.isfile('../first.tar.tbz2')
 
257
        from bz2 import BZ2File
 
258
        tf = TarFile('../first.tar.tbz2', 
 
259
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
260
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
261
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
262
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
263
        tf = TarFile('../first2.tar')
 
264
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
265
 
 
266
    def test_diff(self):
 
267
        self.example_branch()
 
268
        file('hello', 'wt').write('hello world!')
 
269
        self.runbzr('commit -m fixing hello')
 
270
        output = self.runbzr('diff -r 2..3', backtick=1)
 
271
        self.assert_('\n+hello world!' in output)
 
272
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
273
        self.assert_('\n+baz' in output)
 
274
 
 
275
    def test_diff_branches(self):
 
276
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
277
        branch = Branch.initialize('branch1')
 
278
        branch.add(['file'])
 
279
        branch.commit('add file')
 
280
        copy_branch(branch, 'branch2')
 
281
        print >> open('branch2/file', 'w'), 'new content'
 
282
        branch2 = Branch.open('branch2')
 
283
        branch2.commit('update file')
 
284
        # should open branch1 and diff against branch2, 
 
285
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
286
        self.assertEquals(("=== modified file 'file'\n"
 
287
                           "--- file\n"
 
288
                           "+++ file\n"
 
289
                           "@@ -1,1 +1,1 @@\n"
 
290
                           "-new content\n"
 
291
                           "+contents of branch1/file\n"
 
292
                           "\n", ''), output)
 
293
 
 
294
    def test_branch(self):
 
295
        """Branch from one branch to another."""
 
296
        os.mkdir('a')
 
297
        os.chdir('a')
 
298
        self.example_branch()
 
299
        os.chdir('..')
 
300
        self.runbzr('branch a b')
 
301
        self.runbzr('branch a c -r 1')
 
302
        os.chdir('b')
 
303
        self.runbzr('commit -m foo --unchanged')
 
304
        os.chdir('..')
 
305
        # naughty - abstraction violations RBC 20050928  
 
306
        print "test_branch used to delete the stores, how is this meant to work ?"
 
307
        #shutil.rmtree('a/.bzr/revision-store')
 
308
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
309
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
310
        self.runbzr('branch a d --basis b')
 
311
 
 
312
    def test_merge(self):
 
313
        from bzrlib.branch import Branch
 
314
        
 
315
        os.mkdir('a')
 
316
        os.chdir('a')
 
317
        self.example_branch()
 
318
        os.chdir('..')
 
319
        self.runbzr('branch a b')
 
320
        os.chdir('b')
 
321
        file('goodbye', 'wt').write('quux')
 
322
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
323
 
 
324
        os.chdir('../a')
 
325
        file('hello', 'wt').write('quuux')
 
326
        # We can't merge when there are in-tree changes
 
327
        self.runbzr('merge ../b', retcode=1)
 
328
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
329
        self.runbzr('merge ../b')
 
330
        self.check_file_contents('goodbye', 'quux')
 
331
        # Merging a branch pulls its revision into the tree
 
332
        a = Branch.open('.')
 
333
        b = Branch.open('../b')
 
334
        a.get_revision_xml(b.last_revision())
 
335
        self.log('pending merges: %s', a.pending_merges())
 
336
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
337
        #        % (a.pending_merges(), b.last_patch())
 
338
 
 
339
    def test_merge_with_missing_file(self):
 
340
        """Merge handles missing file conflicts"""
 
341
        os.mkdir('a')
 
342
        os.chdir('a')
 
343
        os.mkdir('sub')
 
344
        print >> file('sub/a.txt', 'wb'), "hello"
 
345
        print >> file('b.txt', 'wb'), "hello"
 
346
        print >> file('sub/c.txt', 'wb'), "hello"
 
347
        self.runbzr('init')
 
348
        self.runbzr('add')
 
349
        self.runbzr(('commit', '-m', 'added a'))
 
350
        self.runbzr('branch . ../b')
 
351
        print >> file('sub/a.txt', 'ab'), "there"
 
352
        print >> file('b.txt', 'ab'), "there"
 
353
        print >> file('sub/c.txt', 'ab'), "there"
 
354
        self.runbzr(('commit', '-m', 'Added there'))
 
355
        os.unlink('sub/a.txt')
 
356
        os.unlink('sub/c.txt')
 
357
        os.rmdir('sub')
 
358
        os.unlink('b.txt')
 
359
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
360
        os.chdir('../b')
 
361
        print >> file('sub/a.txt', 'ab'), "something"
 
362
        print >> file('b.txt', 'ab'), "something"
 
363
        print >> file('sub/c.txt', 'ab'), "something"
 
364
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
365
        self.runbzr('merge ../a/')
 
366
        assert os.path.exists('sub/a.txt.THIS')
 
367
        assert os.path.exists('sub/a.txt.BASE')
 
368
        os.chdir('../a')
 
369
        self.runbzr('merge ../b/')
 
370
        assert os.path.exists('sub/a.txt.OTHER')
 
371
        assert os.path.exists('sub/a.txt.BASE')
 
372
 
 
373
    def test_pull(self):
 
374
        """Pull changes from one branch to another."""
 
375
        os.mkdir('a')
 
376
        os.chdir('a')
 
377
 
 
378
        self.example_branch()
 
379
        self.runbzr('pull', retcode=1)
 
380
        self.runbzr('missing', retcode=1)
 
381
        self.runbzr('missing .')
 
382
        self.runbzr('missing')
 
383
        self.runbzr('pull')
 
384
        self.runbzr('pull /', retcode=1)
 
385
        self.runbzr('pull')
 
386
 
 
387
        os.chdir('..')
 
388
        self.runbzr('branch a b')
 
389
        os.chdir('b')
 
390
        self.runbzr('pull')
 
391
        os.mkdir('subdir')
 
392
        self.runbzr('add subdir')
 
393
        self.runbzr('commit -m blah --unchanged')
 
394
        os.chdir('../a')
 
395
        a = Branch.open('.')
 
396
        b = Branch.open('../b')
 
397
        assert a.revision_history() == b.revision_history()[:-1]
 
398
        self.runbzr('pull ../b')
 
399
        assert a.revision_history() == b.revision_history()
 
400
        self.runbzr('commit -m blah2 --unchanged')
 
401
        os.chdir('../b')
 
402
        self.runbzr('commit -m blah3 --unchanged')
 
403
        self.runbzr('pull ../a', retcode=1)
 
404
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
405
        return
 
406
        os.chdir('../a')
 
407
        self.runbzr('merge ../b')
 
408
        self.runbzr('commit -m blah4 --unchanged')
 
409
        os.chdir('../b/subdir')
 
410
        self.runbzr('pull ../../a')
 
411
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
412
        self.runbzr('commit -m blah5 --unchanged')
 
413
        self.runbzr('commit -m blah6 --unchanged')
 
414
        os.chdir('..')
 
415
        self.runbzr('pull ../a')
 
416
        os.chdir('../a')
 
417
        self.runbzr('commit -m blah7 --unchanged')
 
418
        self.runbzr('merge ../b')
 
419
        self.runbzr('commit -m blah8 --unchanged')
 
420
        self.runbzr('pull ../b')
 
421
        self.runbzr('pull ../b')
 
422
 
 
423
    def test_locations(self):
 
424
        """Using and remembering different locations"""
 
425
        os.mkdir('a')
 
426
        os.chdir('a')
 
427
        self.runbzr('init')
 
428
        self.runbzr('commit -m unchanged --unchanged')
 
429
        self.runbzr('pull', retcode=1)
 
430
        self.runbzr('merge', retcode=1)
 
431
        self.runbzr('branch . ../b')
 
432
        os.chdir('../b')
 
433
        self.runbzr('pull')
 
434
        self.runbzr('branch . ../c')
 
435
        self.runbzr('pull ../c')
 
436
        self.runbzr('merge')
 
437
        os.chdir('../a')
 
438
        self.runbzr('pull ../b')
 
439
        self.runbzr('pull')
 
440
        self.runbzr('pull ../c')
 
441
        self.runbzr('branch ../c ../d')
 
442
        shutil.rmtree('../c')
 
443
        self.runbzr('pull')
 
444
        os.chdir('../b')
 
445
        self.runbzr('pull')
 
446
        os.chdir('../d')
 
447
        self.runbzr('pull', retcode=1)
 
448
        self.runbzr('pull ../a --remember')
 
449
        self.runbzr('pull')
 
450
        
 
451
    def test_add_reports(self):
 
452
        """add command prints the names of added files."""
 
453
        b = Branch.initialize('.')
 
454
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
455
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
456
        # the ordering is not defined at the moment
 
457
        results = sorted(out.rstrip('\n').split('\n'))
 
458
        self.assertEquals(['added dir',
 
459
                           'added dir'+os.sep+'sub.txt',
 
460
                           'added top.txt',],
 
461
                          results)
 
462
 
 
463
    def test_add_quiet_is(self):
 
464
        """add -q does not print the names of added files."""
 
465
        b = Branch.initialize('.')
 
466
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
467
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
468
        # the ordering is not defined at the moment
 
469
        results = sorted(out.rstrip('\n').split('\n'))
 
470
        self.assertEquals([''], results)
 
471
 
 
472
    def test_unknown_command(self):
 
473
        """Handling of unknown command."""
 
474
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
475
                                         retcode=1)
 
476
        self.assertEquals(out, '')
 
477
        err.index('unknown command')
 
478
 
 
479
    def test_conflicts(self):
 
480
        """Handling of merge conflicts"""
 
481
        os.mkdir('base')
 
482
        os.chdir('base')
 
483
        file('hello', 'wb').write("hi world")
 
484
        file('answer', 'wb').write("42")
 
485
        self.runbzr('init')
 
486
        self.runbzr('add')
 
487
        self.runbzr('commit -m base')
 
488
        self.runbzr('branch . ../other')
 
489
        self.runbzr('branch . ../this')
 
490
        os.chdir('../other')
 
491
        file('hello', 'wb').write("Hello.")
 
492
        file('answer', 'wb').write("Is anyone there?")
 
493
        self.runbzr('commit -m other')
 
494
        os.chdir('../this')
 
495
        file('hello', 'wb').write("Hello, world")
 
496
        self.runbzr('mv answer question')
 
497
        file('question', 'wb').write("What do you get when you multiply six"
 
498
                                   "times nine?")
 
499
        self.runbzr('commit -m this')
 
500
        self.runbzr('merge ../other')
 
501
        result = self.runbzr('conflicts', backtick=1)
 
502
        self.assertEquals(result, "hello\nquestion\n")
 
503
        result = self.runbzr('status', backtick=1)
 
504
        assert "conflicts:\n  hello\n  question\n" in result, result
 
505
        self.runbzr('resolve hello')
 
506
        result = self.runbzr('conflicts', backtick=1)
 
507
        self.assertEquals(result, "question\n")
 
508
        self.runbzr('commit -m conflicts', retcode=1)
 
509
        self.runbzr('resolve --all')
 
510
        result = self.runbzr('conflicts', backtick=1)
 
511
        self.runbzr('commit -m conflicts')
 
512
        self.assertEquals(result, "")
 
513
 
 
514
def listdir_sorted(dir):
 
515
    L = os.listdir(dir)
 
516
    L.sort()
 
517
    return L
138
518
 
139
519
 
140
520
class OldTests(ExternalBase):
141
 
    # old tests moved from ./testbzr
142
 
    def runTest(self):
 
521
    """old tests moved from ./testbzr."""
 
522
 
 
523
    def test_bzr(self):
143
524
        from os import chdir, mkdir
144
525
        from os.path import exists
145
 
        import os
146
526
 
147
527
        runbzr = self.runbzr
148
 
        backtick = self.backtick
 
528
        capture = self.capture
149
529
        progress = self.log
150
530
 
151
531
        progress("basic branch creation")
153
533
        chdir('branch1')
154
534
        runbzr('init')
155
535
 
156
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
536
        self.assertEquals(capture('root').rstrip(),
157
537
                          os.path.join(self.test_dir, 'branch1'))
158
538
 
159
539
        progress("status of new file")
162
542
        f.write('hello world!\n')
163
543
        f.close()
164
544
 
165
 
        out = backtick("bzr unknowns")
166
 
        self.assertEquals(out, 'test.txt\n')
 
545
        self.assertEquals(capture('unknowns'), 'test.txt\n')
167
546
 
168
 
        out = backtick("bzr status")
 
547
        out = capture("status")
169
548
        assert out == 'unknown:\n  test.txt\n'
170
549
 
171
 
        out = backtick("bzr status --all")
 
550
        out = capture("status --all")
172
551
        assert out == "unknown:\n  test.txt\n"
173
552
 
174
 
        out = backtick("bzr status test.txt --all")
 
553
        out = capture("status test.txt --all")
175
554
        assert out == "unknown:\n  test.txt\n"
176
555
 
177
556
        f = file('test2.txt', 'wt')
178
557
        f.write('goodbye cruel world...\n')
179
558
        f.close()
180
559
 
181
 
        out = backtick("bzr status test.txt")
 
560
        out = capture("status test.txt")
182
561
        assert out == "unknown:\n  test.txt\n"
183
562
 
184
 
        out = backtick("bzr status")
 
563
        out = capture("status")
185
564
        assert out == ("unknown:\n"
186
565
                       "  test.txt\n"
187
566
                       "  test2.txt\n")
189
568
        os.unlink('test2.txt')
190
569
 
191
570
        progress("command aliases")
192
 
        out = backtick("bzr st --all")
 
571
        out = capture("st --all")
193
572
        assert out == ("unknown:\n"
194
573
                       "  test.txt\n")
195
574
 
196
 
        out = backtick("bzr stat")
 
575
        out = capture("stat")
197
576
        assert out == ("unknown:\n"
198
577
                       "  test.txt\n")
199
578
 
203
582
        runbzr("help commands")
204
583
        runbzr("help slartibartfast", 1)
205
584
 
206
 
        out = backtick("bzr help ci")
 
585
        out = capture("help ci")
207
586
        out.index('aliases: ')
208
587
 
209
588
        progress("can't rename unversioned file")
212
591
        progress("adding a file")
213
592
 
214
593
        runbzr("add test.txt")
215
 
        assert backtick("bzr unknowns") == ''
216
 
        assert backtick("bzr status --all") == ("added:\n"
 
594
        assert capture("unknowns") == ''
 
595
        assert capture("status --all") == ("added:\n"
217
596
                                                "  test.txt\n")
218
597
 
219
598
        progress("rename newly-added file")
221
600
        assert os.path.exists("hello.txt")
222
601
        assert not os.path.exists("test.txt")
223
602
 
224
 
        assert backtick("bzr revno") == '0\n'
 
603
        assert capture("revno") == '0\n'
225
604
 
226
605
        progress("add first revision")
227
606
        runbzr(['commit', '-m', 'add first revision'])
235
614
        runbzr("add sub1")
236
615
        runbzr("rename sub1 sub2")
237
616
        runbzr("move hello.txt sub2")
238
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
617
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
239
618
 
240
619
        assert exists("sub2")
241
620
        assert exists("sub2/hello.txt")
256
635
        runbzr(['commit', '-m', 'rename nested subdirectories'])
257
636
 
258
637
        chdir('sub1/sub2')
259
 
        self.assertEquals(backtick('bzr root')[:-1],
 
638
        self.assertEquals(capture('root')[:-1],
260
639
                          os.path.join(self.test_dir, 'branch1'))
261
640
        runbzr('move ../hello.txt .')
262
641
        assert exists('./hello.txt')
263
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
264
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
642
        self.assertEquals(capture('relpath hello.txt'),
 
643
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
644
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
265
645
        runbzr(['commit', '-m', 'move to parent directory'])
266
646
        chdir('..')
267
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
647
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
268
648
 
269
649
        runbzr('move sub2/hello.txt .')
270
650
        assert exists('hello.txt')
279
659
 
280
660
        runbzr('commit -F msg.tmp')
281
661
 
282
 
        assert backtick('bzr revno') == '5\n'
 
662
        assert capture('revno') == '5\n'
283
663
        runbzr('export -r 5 export-5.tmp')
284
664
        runbzr('export export.tmp')
285
665
 
287
667
        runbzr('log -v')
288
668
        runbzr('log -v --forward')
289
669
        runbzr('log -m', retcode=1)
290
 
        log_out = backtick('bzr log -m commit')
 
670
        log_out = capture('log -m commit')
291
671
        assert "this is my new commit" in log_out
292
672
        assert "rename nested" not in log_out
293
673
        assert 'revision-id' not in log_out
294
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
674
        assert 'revision-id' in capture('log --show-ids -m commit')
295
675
 
296
676
 
297
677
        progress("file with spaces in name")
307
687
 
308
688
        runbzr('info')
309
689
 
310
 
 
311
 
 
312
 
 
313
 
 
314
 
 
315
 
        chdir('..')
316
 
        chdir('..')
317
 
        progress('branch')
318
 
        assert os.path.exists('branch1')
319
 
        assert not os.path.exists('branch2')
320
 
        # Can't create a branch if it already exists
321
 
        runbzr('branch branch1', retcode=1)
322
 
        # Can't create a branch if its parent doesn't exist
323
 
        runbzr('branch /unlikely/to/exist', retcode=1)
324
 
        runbzr('branch branch1 branch2')
325
 
        assert exists('branch2')
326
 
        assert exists('branch2/sub1')
327
 
        assert exists('branch2/sub1/hello.txt')
328
 
        
329
 
        runbzr('branch --revision 0 branch1 branch3')
330
 
        assert not exists('branch3/sub1/hello.txt')
331
 
        runbzr('branch --revision 0..3 branch1 branch4', retcode=1)
332
 
 
333
 
        progress("pull")
334
 
        chdir('branch1')
335
 
        runbzr('pull', retcode=1)
336
 
        runbzr('pull ../branch2')
337
 
        chdir('.bzr')
338
 
        runbzr('pull')
339
 
        runbzr('commit --unchanged -m empty')
340
 
        runbzr('pull')
341
 
        chdir('../../branch2')
342
 
        runbzr('pull')
343
 
        runbzr('commit --unchanged -m empty')
344
 
        chdir('../branch1')
345
 
        runbzr('commit --unchanged -m empty')
346
 
        runbzr('pull', retcode=1)
347
 
        chdir ('..')
348
 
 
349
 
        progress('status after remove')
350
 
        mkdir('status-after-remove')
351
 
        # see mail from William Dodé, 2005-05-25
352
 
        # $ bzr init; touch a; bzr add a; bzr commit -m "add a"
353
 
        #     * looking for changes...
354
 
        #     added a
355
 
        #     * commited r1
356
 
        #     $ bzr remove a
357
 
        #     $ bzr status
358
 
        #     bzr: local variable 'kind' referenced before assignment
359
 
        #     at /vrac/python/bazaar-ng/bzrlib/diff.py:286 in compare_trees()
360
 
        #     see ~/.bzr.log for debug information
361
 
        chdir('status-after-remove')
362
 
        runbzr('init')
363
 
        file('a', 'w').write('foo')
364
 
        runbzr('add a')
365
 
        runbzr(['commit', '-m', 'add a'])
366
 
        runbzr('remove a')
367
 
        runbzr('status')
368
 
 
369
 
        chdir('..')
370
 
 
371
 
 
372
 
 
373
 
        progress("recursive and non-recursive add")
374
 
        mkdir('no-recurse')
375
 
        chdir('no-recurse')
376
 
        runbzr('init')
377
 
        mkdir('foo')
378
 
        fp = os.path.join('foo', 'test.txt')
379
 
        f = file(fp, 'w')
380
 
        f.write('hello!\n')
381
 
        f.close()
382
 
        runbzr('add --no-recurse foo')
383
 
        runbzr('file-id foo')
384
 
        runbzr('file-id ' + fp, 1)      # not versioned yet
385
 
        runbzr('commit -m add-dir-only')
386
 
 
387
 
        self.runbzr('file-id ' + fp, 1)      # still not versioned 
388
 
 
389
 
        self.runbzr('add foo')
390
 
        self.runbzr('file-id ' + fp)
391
 
        self.runbzr('commit -m add-sub-file')
392
 
 
393
 
        chdir('..')
394
 
 
395
 
 
396
 
 
397
 
class RevertCommand(ExternalBase):
398
 
    def runTest(self):
399
 
        self.runbzr('init')
400
 
 
401
 
        file('hello', 'wt').write('foo')
402
 
        self.runbzr('add hello')
403
 
        self.runbzr('commit -m setup hello')
404
 
        
405
 
        file('hello', 'wt').write('bar')
406
 
        self.runbzr('revert hello')
407
 
        self.check_file_contents('hello', 'foo')
408
 
 
 
690
        if has_symlinks():
 
691
            progress("symlinks")
 
692
            mkdir('symlinks')
 
693
            chdir('symlinks')
 
694
            runbzr('init')
 
695
            os.symlink("NOWHERE1", "link1")
 
696
            runbzr('add link1')
 
697
            assert self.capture('unknowns') == ''
 
698
            runbzr(['commit', '-m', '1: added symlink link1'])
 
699
    
 
700
            mkdir('d1')
 
701
            runbzr('add d1')
 
702
            assert self.capture('unknowns') == ''
 
703
            os.symlink("NOWHERE2", "d1/link2")
 
704
            assert self.capture('unknowns') == 'd1/link2\n'
 
705
            # is d1/link2 found when adding d1
 
706
            runbzr('add d1')
 
707
            assert self.capture('unknowns') == ''
 
708
            os.symlink("NOWHERE3", "d1/link3")
 
709
            assert self.capture('unknowns') == 'd1/link3\n'
 
710
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
711
    
 
712
            runbzr('rename d1 d2')
 
713
            runbzr('move d2/link2 .')
 
714
            runbzr('move link1 d2')
 
715
            assert os.readlink("./link2") == "NOWHERE2"
 
716
            assert os.readlink("d2/link1") == "NOWHERE1"
 
717
            runbzr('add d2/link3')
 
718
            runbzr('diff')
 
719
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
720
    
 
721
            os.unlink("link2")
 
722
            os.symlink("TARGET 2", "link2")
 
723
            os.unlink("d2/link1")
 
724
            os.symlink("TARGET 1", "d2/link1")
 
725
            runbzr('diff')
 
726
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
727
            runbzr(['commit', '-m', '4: retarget of two links'])
 
728
    
 
729
            runbzr('remove d2/link1')
 
730
            assert self.capture('unknowns') == 'd2/link1\n'
 
731
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
732
            # try with the rm alias
 
733
            runbzr('add d2/link1')
 
734
            runbzr(['commit', '-m', '6: add d2/link1'])
 
735
            runbzr('rm d2/link1')
 
736
            assert self.capture('unknowns') == 'd2/link1\n'
 
737
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
738
    
 
739
            os.mkdir("d1")
 
740
            runbzr('add d1')
 
741
            runbzr('rename d2/link3 d1/link3new')
 
742
            assert self.capture('unknowns') == 'd2/link1\n'
 
743
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
744
            
 
745
            runbzr(['check'])
 
746
            
 
747
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
748
            chdir("exp1.tmp")
 
749
            assert listdir_sorted(".") == [ "link1" ]
 
750
            assert os.readlink("link1") == "NOWHERE1"
 
751
            chdir("..")
 
752
            
 
753
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
754
            chdir("exp2.tmp")
 
755
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
756
            chdir("..")
 
757
            
 
758
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
759
            chdir("exp3.tmp")
 
760
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
761
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
762
            assert os.readlink("d2/link1") == "NOWHERE1"
 
763
            assert os.readlink("link2")    == "NOWHERE2"
 
764
            chdir("..")
 
765
            
 
766
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
767
            chdir("exp4.tmp")
 
768
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
769
            assert os.readlink("d2/link1") == "TARGET 1"
 
770
            assert os.readlink("link2")    == "TARGET 2"
 
771
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
772
            chdir("..")
 
773
            
 
774
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
775
            chdir("exp5.tmp")
 
776
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
777
            assert os.path.islink("link2")
 
778
            assert listdir_sorted("d2")== [ "link3" ]
 
779
            chdir("..")
 
780
            
 
781
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
782
            chdir("exp6.tmp")
 
783
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
784
            assert listdir_sorted("d1") == [ "link3new" ]
 
785
            assert listdir_sorted("d2") == []
 
786
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
787
            chdir("..")
 
788
        else:
 
789
            progress("skipping symlink tests")
 
790
 
 
791
 
 
792
class HttpTests(TestCaseWithWebserver):
 
793
    """Test bzr ui commands against remote branches."""
 
794
 
 
795
    def test_branch(self):
 
796
        os.mkdir('from')
 
797
        branch = Branch.initialize('from')
 
798
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
799
        url = self.get_remote_url('from')
 
800
        self.run_bzr('branch', url, 'to')
 
801
        branch = Branch.open('to')
 
802
        self.assertEqual(1, len(branch.revision_history()))