~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-10 08:27:26 UTC
  • mfrom: (1185.15.9)
  • Revision ID: robertc@robertcollins.net-20051010082726-b709d6577691ba69
mergeĀ fromĀ upstream

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
 
 
26
 
29
27
from cStringIO import StringIO
 
28
import os
 
29
import shutil
30
30
import sys
31
31
import os
32
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
33
37
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
34
 
from bzrlib.branch import Branch
 
38
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
35
39
 
36
40
 
37
41
class ExternalBase(TestCaseInTempDir):
101
105
        self.runbzr("add hello.txt")
102
106
        self.runbzr("commit -m added")
103
107
 
 
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
 
104
114
    def test_ignore_patterns(self):
105
115
        from bzrlib.branch import Branch
106
116
        
123
133
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
124
134
        self.runbzr('ignore *.blah')
125
135
        self.assertEquals(list(b.unknowns()), [])
126
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
136
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
127
137
 
128
138
        # 'ignore' works when then .bzrignore file already exists
129
139
        file('garh', 'wt').write('garh')
131
141
        assert self.capture('unknowns') == 'garh\n'
132
142
        self.runbzr('ignore garh')
133
143
        self.assertEquals(list(b.unknowns()), [])
134
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
144
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
135
145
 
136
146
    def test_revert(self):
137
147
        self.runbzr('init')
143
153
        file('goodbye', 'wt').write('baz')
144
154
        self.runbzr('add goodbye')
145
155
        self.runbzr('commit -m setup goodbye')
146
 
        
 
156
 
147
157
        file('hello', 'wt').write('bar')
148
158
        file('goodbye', 'wt').write('qux')
149
159
        self.runbzr('revert hello')
158
168
        os.rmdir('revertdir')
159
169
        self.runbzr('revert')
160
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
        
161
177
        file('hello', 'wt').write('xyz')
162
178
        self.runbzr('commit -m xyz hello')
163
179
        self.runbzr('revert -r 1 hello')
164
180
        self.check_file_contents('hello', 'foo')
165
181
        self.runbzr('revert hello')
166
182
        self.check_file_contents('hello', 'xyz')
 
183
        os.chdir('revertdir')
 
184
        self.runbzr('revert')
 
185
        os.chdir('..')
 
186
 
167
187
 
168
188
    def test_mv_modes(self):
169
189
        """Test two modes of operation for mv"""
177
197
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
178
198
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
179
199
 
180
 
 
181
200
    def test_main_version(self):
182
201
        """Check output from version command and master option is reasonable"""
183
202
        # output is intentionally passed through to stdout so that we
202
221
        test.runbzr('add goodbye')
203
222
        test.runbzr('commit -m setup goodbye')
204
223
 
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)
 
224
    def test_export(self):
 
225
        os.mkdir('branch')
 
226
        os.chdir('branch')
 
227
        self.example_branch()
 
228
        self.runbzr('export ../latest')
 
229
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
230
        self.runbzr('export ../first -r 1')
 
231
        assert not os.path.exists('../first/goodbye')
 
232
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
233
        self.runbzr('export ../first.gz -r 1')
 
234
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
235
        self.runbzr('export ../first.bz2 -r 1')
 
236
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
237
        self.runbzr('export ../first.tar -r 1')
 
238
        assert os.path.isfile('../first.tar')
 
239
        from tarfile import TarFile
 
240
        tf = TarFile('../first.tar')
 
241
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
242
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
243
        self.runbzr('export ../first.tar.gz -r 1')
 
244
        assert os.path.isfile('../first.tar.gz')
 
245
        self.runbzr('export ../first.tbz2 -r 1')
 
246
        assert os.path.isfile('../first.tbz2')
 
247
        self.runbzr('export ../first.tar.bz2 -r 1')
 
248
        assert os.path.isfile('../first.tar.bz2')
 
249
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
250
        assert os.path.isfile('../first.tar.tbz2')
 
251
        from bz2 import BZ2File
 
252
        tf = TarFile('../first.tar.tbz2', 
 
253
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
254
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
255
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
256
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
257
        tf = TarFile('../first2.tar')
 
258
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
259
 
 
260
    def test_diff(self):
 
261
        self.example_branch()
 
262
        file('hello', 'wt').write('hello world!')
 
263
        self.runbzr('commit -m fixing hello')
 
264
        output = self.runbzr('diff -r 2..3', backtick=1)
 
265
        self.assert_('\n+hello world!' in output)
 
266
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
267
        self.assert_('\n+baz' in output)
 
268
 
 
269
    def test_diff_branches(self):
 
270
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
271
        branch = Branch.initialize('branch1')
 
272
        branch.add(['file'])
 
273
        branch.commit('add file')
 
274
        copy_branch(branch, 'branch2')
 
275
        print >> open('branch2/file', 'w'), 'new content'
 
276
        branch2 = Branch.open('branch2')
 
277
        branch2.commit('update file')
 
278
        # should open branch1 and diff against branch2, 
 
279
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
280
        self.assertEquals(("=== modified file 'file'\n"
 
281
                           "--- file\n"
 
282
                           "+++ file\n"
 
283
                           "@@ -1,1 +1,1 @@\n"
 
284
                           "-new content\n"
 
285
                           "+contents of branch1/file\n"
 
286
                           "\n", ''), output)
 
287
 
 
288
    def test_branch(self):
 
289
        """Branch from one branch to another."""
 
290
        os.mkdir('a')
 
291
        os.chdir('a')
 
292
        self.example_branch()
 
293
        os.chdir('..')
 
294
        self.runbzr('branch a b')
 
295
        self.runbzr('branch a c -r 1')
 
296
        os.chdir('b')
 
297
        self.runbzr('commit -m foo --unchanged')
 
298
        os.chdir('..')
 
299
        # naughty - abstraction violations RBC 20050928  
 
300
        print "test_branch used to delete the stores, how is this meant to work ?"
 
301
        #shutil.rmtree('a/.bzr/revision-store')
 
302
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
303
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
304
        self.runbzr('branch a d --basis b')
222
305
 
223
306
    def test_merge(self):
224
307
        from bzrlib.branch import Branch
242
325
        # Merging a branch pulls its revision into the tree
243
326
        a = Branch.open('.')
244
327
        b = Branch.open('../b')
245
 
        a.get_revision_xml(b.last_patch())
 
328
        a.get_revision_xml(b.last_revision())
246
329
        self.log('pending merges: %s', a.pending_merges())
247
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
330
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
248
331
        #        % (a.pending_merges(), b.last_patch())
249
332
 
 
333
    def test_merge_with_missing_file(self):
 
334
        """Merge handles missing file conflicts"""
 
335
        os.mkdir('a')
 
336
        os.chdir('a')
 
337
        os.mkdir('sub')
 
338
        print >> file('sub/a.txt', 'wb'), "hello"
 
339
        print >> file('b.txt', 'wb'), "hello"
 
340
        print >> file('sub/c.txt', 'wb'), "hello"
 
341
        self.runbzr('init')
 
342
        self.runbzr('add')
 
343
        self.runbzr(('commit', '-m', 'added a'))
 
344
        self.runbzr('branch . ../b')
 
345
        print >> file('sub/a.txt', 'ab'), "there"
 
346
        print >> file('b.txt', 'ab'), "there"
 
347
        print >> file('sub/c.txt', 'ab'), "there"
 
348
        self.runbzr(('commit', '-m', 'Added there'))
 
349
        os.unlink('sub/a.txt')
 
350
        os.unlink('sub/c.txt')
 
351
        os.rmdir('sub')
 
352
        os.unlink('b.txt')
 
353
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
354
        os.chdir('../b')
 
355
        print >> file('sub/a.txt', 'ab'), "something"
 
356
        print >> file('b.txt', 'ab'), "something"
 
357
        print >> file('sub/c.txt', 'ab'), "something"
 
358
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
359
        self.runbzr('merge ../a/')
 
360
        assert os.path.exists('sub/a.txt.THIS')
 
361
        assert os.path.exists('sub/a.txt.BASE')
 
362
        os.chdir('../a')
 
363
        self.runbzr('merge ../b/')
 
364
        assert os.path.exists('sub/a.txt.OTHER')
 
365
        assert os.path.exists('sub/a.txt.BASE')
 
366
 
250
367
    def test_pull(self):
251
368
        """Pull changes from one branch to another."""
252
369
        os.mkdir('a')
265
382
        self.runbzr('branch a b')
266
383
        os.chdir('b')
267
384
        self.runbzr('pull')
 
385
        os.mkdir('subdir')
 
386
        self.runbzr('add subdir')
268
387
        self.runbzr('commit -m blah --unchanged')
269
388
        os.chdir('../a')
270
389
        a = Branch.open('.')
276
395
        os.chdir('../b')
277
396
        self.runbzr('commit -m blah3 --unchanged')
278
397
        self.runbzr('pull ../a', retcode=1)
 
398
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
399
        return
279
400
        os.chdir('../a')
280
401
        self.runbzr('merge ../b')
281
402
        self.runbzr('commit -m blah4 --unchanged')
282
 
        os.chdir('../b')
 
403
        os.chdir('../b/subdir')
 
404
        self.runbzr('pull ../../a')
 
405
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
406
        self.runbzr('commit -m blah5 --unchanged')
 
407
        self.runbzr('commit -m blah6 --unchanged')
 
408
        os.chdir('..')
283
409
        self.runbzr('pull ../a')
284
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
410
        os.chdir('../a')
 
411
        self.runbzr('commit -m blah7 --unchanged')
 
412
        self.runbzr('merge ../b')
 
413
        self.runbzr('commit -m blah8 --unchanged')
 
414
        self.runbzr('pull ../b')
 
415
        self.runbzr('pull ../b')
 
416
 
 
417
    def test_locations(self):
 
418
        """Using and remembering different locations"""
 
419
        os.mkdir('a')
 
420
        os.chdir('a')
 
421
        self.runbzr('init')
 
422
        self.runbzr('commit -m unchanged --unchanged')
 
423
        self.runbzr('pull', retcode=1)
 
424
        self.runbzr('merge', retcode=1)
 
425
        self.runbzr('branch . ../b')
 
426
        os.chdir('../b')
 
427
        self.runbzr('pull')
 
428
        self.runbzr('branch . ../c')
 
429
        self.runbzr('pull ../c')
 
430
        self.runbzr('merge')
 
431
        os.chdir('../a')
 
432
        self.runbzr('pull ../b')
 
433
        self.runbzr('pull')
 
434
        self.runbzr('pull ../c')
 
435
        self.runbzr('branch ../c ../d')
 
436
        shutil.rmtree('../c')
 
437
        self.runbzr('pull')
 
438
        os.chdir('../b')
 
439
        self.runbzr('pull')
 
440
        os.chdir('../d')
 
441
        self.runbzr('pull', retcode=1)
 
442
        self.runbzr('pull ../a --remember')
 
443
        self.runbzr('pull')
285
444
        
286
445
    def test_add_reports(self):
287
446
        """add command prints the names of added files."""
291
450
        # the ordering is not defined at the moment
292
451
        results = sorted(out.rstrip('\n').split('\n'))
293
452
        self.assertEquals(['added dir',
294
 
                           'added dir/sub.txt',
 
453
                           'added dir'+os.sep+'sub.txt',
295
454
                           'added top.txt',],
296
455
                          results)
297
456
 
301
460
                                         retcode=1)
302
461
        self.assertEquals(out, '')
303
462
        err.index('unknown command')
304
 
        
 
463
 
 
464
    def test_conflicts(self):
 
465
        """Handling of merge conflicts"""
 
466
        os.mkdir('base')
 
467
        os.chdir('base')
 
468
        file('hello', 'wb').write("hi world")
 
469
        file('answer', 'wb').write("42")
 
470
        self.runbzr('init')
 
471
        self.runbzr('add')
 
472
        self.runbzr('commit -m base')
 
473
        self.runbzr('branch . ../other')
 
474
        self.runbzr('branch . ../this')
 
475
        os.chdir('../other')
 
476
        file('hello', 'wb').write("Hello.")
 
477
        file('answer', 'wb').write("Is anyone there?")
 
478
        self.runbzr('commit -m other')
 
479
        os.chdir('../this')
 
480
        file('hello', 'wb').write("Hello, world")
 
481
        self.runbzr('mv answer question')
 
482
        file('question', 'wb').write("What do you get when you multiply six"
 
483
                                   "times nine?")
 
484
        self.runbzr('commit -m this')
 
485
        self.runbzr('merge ../other')
 
486
        result = self.runbzr('conflicts', backtick=1)
 
487
        self.assertEquals(result, "hello\nquestion\n")
 
488
        result = self.runbzr('status', backtick=1)
 
489
        assert "conflicts:\n  hello\n  question\n" in result, result
 
490
        self.runbzr('resolve hello')
 
491
        result = self.runbzr('conflicts', backtick=1)
 
492
        self.assertEquals(result, "question\n")
 
493
        self.runbzr('commit -m conflicts', retcode=1)
 
494
        self.runbzr('resolve --all')
 
495
        result = self.runbzr('conflicts', backtick=1)
 
496
        self.runbzr('commit -m conflicts')
 
497
        self.assertEquals(result, "")
 
498
 
 
499
def listdir_sorted(dir):
 
500
    L = os.listdir(dir)
 
501
    L.sort()
 
502
    return L
305
503
 
306
504
 
307
505
class OldTests(ExternalBase):
474
672
 
475
673
        runbzr('info')
476
674
 
 
675
        if has_symlinks():
 
676
            progress("symlinks")
 
677
            mkdir('symlinks')
 
678
            chdir('symlinks')
 
679
            runbzr('init')
 
680
            os.symlink("NOWHERE1", "link1")
 
681
            runbzr('add link1')
 
682
            assert self.capture('unknowns') == ''
 
683
            runbzr(['commit', '-m', '1: added symlink link1'])
 
684
    
 
685
            mkdir('d1')
 
686
            runbzr('add d1')
 
687
            assert self.capture('unknowns') == ''
 
688
            os.symlink("NOWHERE2", "d1/link2")
 
689
            assert self.capture('unknowns') == 'd1/link2\n'
 
690
            # is d1/link2 found when adding d1
 
691
            runbzr('add d1')
 
692
            assert self.capture('unknowns') == ''
 
693
            os.symlink("NOWHERE3", "d1/link3")
 
694
            assert self.capture('unknowns') == 'd1/link3\n'
 
695
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
696
    
 
697
            runbzr('rename d1 d2')
 
698
            runbzr('move d2/link2 .')
 
699
            runbzr('move link1 d2')
 
700
            assert os.readlink("./link2") == "NOWHERE2"
 
701
            assert os.readlink("d2/link1") == "NOWHERE1"
 
702
            runbzr('add d2/link3')
 
703
            runbzr('diff')
 
704
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
705
    
 
706
            os.unlink("link2")
 
707
            os.symlink("TARGET 2", "link2")
 
708
            os.unlink("d2/link1")
 
709
            os.symlink("TARGET 1", "d2/link1")
 
710
            runbzr('diff')
 
711
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
712
            runbzr(['commit', '-m', '4: retarget of two links'])
 
713
    
 
714
            runbzr('remove d2/link1')
 
715
            assert self.capture('unknowns') == 'd2/link1\n'
 
716
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
717
            # try with the rm alias
 
718
            runbzr('add d2/link1')
 
719
            runbzr(['commit', '-m', '6: add d2/link1'])
 
720
            runbzr('rm d2/link1')
 
721
            assert self.capture('unknowns') == 'd2/link1\n'
 
722
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
723
    
 
724
            os.mkdir("d1")
 
725
            runbzr('add d1')
 
726
            runbzr('rename d2/link3 d1/link3new')
 
727
            assert self.capture('unknowns') == 'd2/link1\n'
 
728
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
729
            
 
730
            runbzr(['check'])
 
731
            
 
732
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
733
            chdir("exp1.tmp")
 
734
            assert listdir_sorted(".") == [ "link1" ]
 
735
            assert os.readlink("link1") == "NOWHERE1"
 
736
            chdir("..")
 
737
            
 
738
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
739
            chdir("exp2.tmp")
 
740
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
741
            chdir("..")
 
742
            
 
743
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
744
            chdir("exp3.tmp")
 
745
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
746
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
747
            assert os.readlink("d2/link1") == "NOWHERE1"
 
748
            assert os.readlink("link2")    == "NOWHERE2"
 
749
            chdir("..")
 
750
            
 
751
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
752
            chdir("exp4.tmp")
 
753
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
754
            assert os.readlink("d2/link1") == "TARGET 1"
 
755
            assert os.readlink("link2")    == "TARGET 2"
 
756
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
757
            chdir("..")
 
758
            
 
759
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
760
            chdir("exp5.tmp")
 
761
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
762
            assert os.path.islink("link2")
 
763
            assert listdir_sorted("d2")== [ "link3" ]
 
764
            chdir("..")
 
765
            
 
766
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
767
            chdir("exp6.tmp")
 
768
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
769
            assert listdir_sorted("d1") == [ "link3new" ]
 
770
            assert listdir_sorted("d2") == []
 
771
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
772
            chdir("..")
 
773
        else:
 
774
            progress("skipping symlink tests")
 
775
 
 
776
 
 
777
class HttpTests(TestCaseWithWebserver):
 
778
    """Test bzr ui commands against remote branches."""
 
779
 
 
780
    def test_branch(self):
 
781
        os.mkdir('from')
 
782
        branch = Branch.initialize('from')
 
783
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
784
        url = self.get_remote_url('from')
 
785
        self.run_bzr('branch', url, 'to')
 
786
        branch = Branch.open('to')
 
787
        self.assertEqual(1, len(branch.revision_history()))