/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-10-11 22:57:45 UTC
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051011225745-5c02a0cfc85b36d1
fixup the verbose-does-nothing for add - add a --quiet instead

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
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
 
 
27
from cStringIO import StringIO
 
28
import os
 
29
import shutil
29
30
import sys
30
 
 
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
 
 
 
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):
44
44
        if isinstance(args, basestring):
45
45
            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):
 
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):
105
56
        self.runbzr('--help')
106
57
        self.runbzr('help')
107
58
        self.runbzr('help commands')
108
59
        self.runbzr('help help')
109
60
        self.runbzr('commit -h')
110
61
 
111
 
 
112
 
class InitBranch(ExternalBase):
113
 
    def runTest(self):
114
 
        import os
 
62
    def test_init_branch(self):
115
63
        self.runbzr(['init'])
116
64
 
117
 
 
118
 
 
119
 
class UserIdentity(ExternalBase):
120
 
    def runTest(self):
 
65
    def test_whoami(self):
121
66
        # this should always identify something, if only "john@localhost"
122
67
        self.runbzr("whoami")
123
68
        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):
 
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):
130
97
        self.runbzr("pants", retcode=1)
131
98
        self.runbzr("--pants off", retcode=1)
132
99
        self.runbzr("diff --message foo", retcode=1)
133
100
 
134
 
 
135
 
 
136
 
class EmptyCommit(ExternalBase):
137
 
    def runTest(self):
 
101
    def test_empty_commit(self):
138
102
        self.runbzr("init")
139
103
        self.build_tree(['hello.txt'])
140
104
        self.runbzr("commit -m empty", retcode=1)
141
105
        self.runbzr("add hello.txt")
142
106
        self.runbzr("commit -m added")
143
107
 
144
 
 
145
 
 
146
 
class IgnorePatterns(ExternalBase):
147
 
    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):
148
115
        from bzrlib.branch import Branch
149
116
        
150
 
        b = Branch('.', init=True)
 
117
        b = Branch.initialize('.')
151
118
        self.assertEquals(list(b.unknowns()), [])
152
119
 
153
120
        file('foo.tmp', 'wt').write('tmp files are ignored')
154
121
        self.assertEquals(list(b.unknowns()), [])
155
 
        assert self.backtick('bzr unknowns') == ''
 
122
        assert self.capture('unknowns') == ''
156
123
 
157
124
        file('foo.c', 'wt').write('int main() {}')
158
125
        self.assertEquals(list(b.unknowns()), ['foo.c'])
159
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
126
        assert self.capture('unknowns') == 'foo.c\n'
160
127
 
161
128
        self.runbzr(['add', 'foo.c'])
162
 
        assert self.backtick('bzr unknowns') == ''
 
129
        assert self.capture('unknowns') == ''
163
130
 
164
131
        # 'ignore' works when creating the .bzignore file
165
132
        file('foo.blah', 'wt').write('blah')
166
133
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
167
134
        self.runbzr('ignore *.blah')
168
135
        self.assertEquals(list(b.unknowns()), [])
169
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
136
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
170
137
 
171
138
        # 'ignore' works when then .bzrignore file already exists
172
139
        file('garh', 'wt').write('garh')
173
140
        self.assertEquals(list(b.unknowns()), ['garh'])
174
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
141
        assert self.capture('unknowns') == 'garh\n'
175
142
        self.runbzr('ignore garh')
176
143
        self.assertEquals(list(b.unknowns()), [])
177
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
178
 
        
179
 
 
 
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
        
 
177
        file('hello', 'wt').write('xyz')
 
178
        self.runbzr('commit -m xyz hello')
 
179
        self.runbzr('revert -r 1 hello')
 
180
        self.check_file_contents('hello', 'foo')
 
181
        self.runbzr('revert hello')
 
182
        self.check_file_contents('hello', 'xyz')
 
183
        os.chdir('revertdir')
 
184
        self.runbzr('revert')
 
185
        os.chdir('..')
 
186
 
 
187
 
 
188
    def test_mv_modes(self):
 
189
        """Test two modes of operation for mv"""
 
190
        from bzrlib.branch import Branch
 
191
        b = Branch.initialize('.')
 
192
        self.build_tree(['a', 'c', 'subdir/'])
 
193
        self.run_bzr_captured(['add', self.test_dir])
 
194
        self.run_bzr_captured(['mv', 'a', 'b'])
 
195
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
196
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
197
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
198
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
199
 
 
200
    def test_main_version(self):
 
201
        """Check output from version command and master option is reasonable"""
 
202
        # output is intentionally passed through to stdout so that we
 
203
        # can see the version being tested
 
204
        output = self.runbzr('version', backtick=1)
 
205
        self.log('bzr version output:')
 
206
        self.log(output)
 
207
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
208
        self.assertNotEqual(output.index('Canonical'), -1)
 
209
        # make sure --version is consistent
 
210
        tmp_output = self.runbzr('--version', backtick=1)
 
211
        self.log('bzr --version output:')
 
212
        self.log(tmp_output)
 
213
        self.assertEquals(output, tmp_output)
 
214
 
 
215
    def example_branch(test):
 
216
        test.runbzr('init')
 
217
        file('hello', 'wt').write('foo')
 
218
        test.runbzr('add hello')
 
219
        test.runbzr('commit -m setup hello')
 
220
        file('goodbye', 'wt').write('baz')
 
221
        test.runbzr('add goodbye')
 
222
        test.runbzr('commit -m setup goodbye')
 
223
 
 
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')
 
305
 
 
306
    def test_merge(self):
 
307
        from bzrlib.branch import Branch
 
308
        
 
309
        os.mkdir('a')
 
310
        os.chdir('a')
 
311
        self.example_branch()
 
312
        os.chdir('..')
 
313
        self.runbzr('branch a b')
 
314
        os.chdir('b')
 
315
        file('goodbye', 'wt').write('quux')
 
316
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
317
 
 
318
        os.chdir('../a')
 
319
        file('hello', 'wt').write('quuux')
 
320
        # We can't merge when there are in-tree changes
 
321
        self.runbzr('merge ../b', retcode=1)
 
322
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
323
        self.runbzr('merge ../b')
 
324
        self.check_file_contents('goodbye', 'quux')
 
325
        # Merging a branch pulls its revision into the tree
 
326
        a = Branch.open('.')
 
327
        b = Branch.open('../b')
 
328
        a.get_revision_xml(b.last_revision())
 
329
        self.log('pending merges: %s', a.pending_merges())
 
330
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
331
        #        % (a.pending_merges(), b.last_patch())
 
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
 
 
367
    def test_pull(self):
 
368
        """Pull changes from one branch to another."""
 
369
        os.mkdir('a')
 
370
        os.chdir('a')
 
371
 
 
372
        self.example_branch()
 
373
        self.runbzr('pull', retcode=1)
 
374
        self.runbzr('missing', retcode=1)
 
375
        self.runbzr('missing .')
 
376
        self.runbzr('missing')
 
377
        self.runbzr('pull')
 
378
        self.runbzr('pull /', retcode=1)
 
379
        self.runbzr('pull')
 
380
 
 
381
        os.chdir('..')
 
382
        self.runbzr('branch a b')
 
383
        os.chdir('b')
 
384
        self.runbzr('pull')
 
385
        os.mkdir('subdir')
 
386
        self.runbzr('add subdir')
 
387
        self.runbzr('commit -m blah --unchanged')
 
388
        os.chdir('../a')
 
389
        a = Branch.open('.')
 
390
        b = Branch.open('../b')
 
391
        assert a.revision_history() == b.revision_history()[:-1]
 
392
        self.runbzr('pull ../b')
 
393
        assert a.revision_history() == b.revision_history()
 
394
        self.runbzr('commit -m blah2 --unchanged')
 
395
        os.chdir('../b')
 
396
        self.runbzr('commit -m blah3 --unchanged')
 
397
        self.runbzr('pull ../a', retcode=1)
 
398
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
399
        return
 
400
        os.chdir('../a')
 
401
        self.runbzr('merge ../b')
 
402
        self.runbzr('commit -m blah4 --unchanged')
 
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('..')
 
409
        self.runbzr('pull ../a')
 
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')
 
444
        
 
445
    def test_add_reports(self):
 
446
        """add command prints the names of added files."""
 
447
        b = Branch.initialize('.')
 
448
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
449
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
450
        # the ordering is not defined at the moment
 
451
        results = sorted(out.rstrip('\n').split('\n'))
 
452
        self.assertEquals(['added dir',
 
453
                           'added dir'+os.sep+'sub.txt',
 
454
                           'added top.txt',],
 
455
                          results)
 
456
 
 
457
    def test_add_quiet_is(self):
 
458
        """add -q does not print the names of added files."""
 
459
        b = Branch.initialize('.')
 
460
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
461
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
462
        # the ordering is not defined at the moment
 
463
        results = sorted(out.rstrip('\n').split('\n'))
 
464
        self.assertEquals([''], results)
 
465
 
 
466
    def test_unknown_command(self):
 
467
        """Handling of unknown command."""
 
468
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
469
                                         retcode=1)
 
470
        self.assertEquals(out, '')
 
471
        err.index('unknown command')
 
472
 
 
473
    def test_conflicts(self):
 
474
        """Handling of merge conflicts"""
 
475
        os.mkdir('base')
 
476
        os.chdir('base')
 
477
        file('hello', 'wb').write("hi world")
 
478
        file('answer', 'wb').write("42")
 
479
        self.runbzr('init')
 
480
        self.runbzr('add')
 
481
        self.runbzr('commit -m base')
 
482
        self.runbzr('branch . ../other')
 
483
        self.runbzr('branch . ../this')
 
484
        os.chdir('../other')
 
485
        file('hello', 'wb').write("Hello.")
 
486
        file('answer', 'wb').write("Is anyone there?")
 
487
        self.runbzr('commit -m other')
 
488
        os.chdir('../this')
 
489
        file('hello', 'wb').write("Hello, world")
 
490
        self.runbzr('mv answer question')
 
491
        file('question', 'wb').write("What do you get when you multiply six"
 
492
                                   "times nine?")
 
493
        self.runbzr('commit -m this')
 
494
        self.runbzr('merge ../other')
 
495
        result = self.runbzr('conflicts', backtick=1)
 
496
        self.assertEquals(result, "hello\nquestion\n")
 
497
        result = self.runbzr('status', backtick=1)
 
498
        assert "conflicts:\n  hello\n  question\n" in result, result
 
499
        self.runbzr('resolve hello')
 
500
        result = self.runbzr('conflicts', backtick=1)
 
501
        self.assertEquals(result, "question\n")
 
502
        self.runbzr('commit -m conflicts', retcode=1)
 
503
        self.runbzr('resolve --all')
 
504
        result = self.runbzr('conflicts', backtick=1)
 
505
        self.runbzr('commit -m conflicts')
 
506
        self.assertEquals(result, "")
 
507
 
 
508
def listdir_sorted(dir):
 
509
    L = os.listdir(dir)
 
510
    L.sort()
 
511
    return L
180
512
 
181
513
 
182
514
class OldTests(ExternalBase):
183
 
    # old tests moved from ./testbzr
184
 
    def runTest(self):
 
515
    """old tests moved from ./testbzr."""
 
516
 
 
517
    def test_bzr(self):
185
518
        from os import chdir, mkdir
186
519
        from os.path import exists
187
 
        import os
188
520
 
189
521
        runbzr = self.runbzr
190
 
        backtick = self.backtick
 
522
        capture = self.capture
191
523
        progress = self.log
192
524
 
193
525
        progress("basic branch creation")
195
527
        chdir('branch1')
196
528
        runbzr('init')
197
529
 
198
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
530
        self.assertEquals(capture('root').rstrip(),
199
531
                          os.path.join(self.test_dir, 'branch1'))
200
532
 
201
533
        progress("status of new file")
204
536
        f.write('hello world!\n')
205
537
        f.close()
206
538
 
207
 
        out = backtick("bzr unknowns")
208
 
        self.assertEquals(out, 'test.txt\n')
 
539
        self.assertEquals(capture('unknowns'), 'test.txt\n')
209
540
 
210
 
        out = backtick("bzr status")
 
541
        out = capture("status")
211
542
        assert out == 'unknown:\n  test.txt\n'
212
543
 
213
 
        out = backtick("bzr status --all")
 
544
        out = capture("status --all")
214
545
        assert out == "unknown:\n  test.txt\n"
215
546
 
216
 
        out = backtick("bzr status test.txt --all")
 
547
        out = capture("status test.txt --all")
217
548
        assert out == "unknown:\n  test.txt\n"
218
549
 
219
550
        f = file('test2.txt', 'wt')
220
551
        f.write('goodbye cruel world...\n')
221
552
        f.close()
222
553
 
223
 
        out = backtick("bzr status test.txt")
 
554
        out = capture("status test.txt")
224
555
        assert out == "unknown:\n  test.txt\n"
225
556
 
226
 
        out = backtick("bzr status")
 
557
        out = capture("status")
227
558
        assert out == ("unknown:\n"
228
559
                       "  test.txt\n"
229
560
                       "  test2.txt\n")
231
562
        os.unlink('test2.txt')
232
563
 
233
564
        progress("command aliases")
234
 
        out = backtick("bzr st --all")
 
565
        out = capture("st --all")
235
566
        assert out == ("unknown:\n"
236
567
                       "  test.txt\n")
237
568
 
238
 
        out = backtick("bzr stat")
 
569
        out = capture("stat")
239
570
        assert out == ("unknown:\n"
240
571
                       "  test.txt\n")
241
572
 
245
576
        runbzr("help commands")
246
577
        runbzr("help slartibartfast", 1)
247
578
 
248
 
        out = backtick("bzr help ci")
 
579
        out = capture("help ci")
249
580
        out.index('aliases: ')
250
581
 
251
582
        progress("can't rename unversioned file")
254
585
        progress("adding a file")
255
586
 
256
587
        runbzr("add test.txt")
257
 
        assert backtick("bzr unknowns") == ''
258
 
        assert backtick("bzr status --all") == ("added:\n"
 
588
        assert capture("unknowns") == ''
 
589
        assert capture("status --all") == ("added:\n"
259
590
                                                "  test.txt\n")
260
591
 
261
592
        progress("rename newly-added file")
263
594
        assert os.path.exists("hello.txt")
264
595
        assert not os.path.exists("test.txt")
265
596
 
266
 
        assert backtick("bzr revno") == '0\n'
 
597
        assert capture("revno") == '0\n'
267
598
 
268
599
        progress("add first revision")
269
600
        runbzr(['commit', '-m', 'add first revision'])
277
608
        runbzr("add sub1")
278
609
        runbzr("rename sub1 sub2")
279
610
        runbzr("move hello.txt sub2")
280
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
611
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
281
612
 
282
613
        assert exists("sub2")
283
614
        assert exists("sub2/hello.txt")
298
629
        runbzr(['commit', '-m', 'rename nested subdirectories'])
299
630
 
300
631
        chdir('sub1/sub2')
301
 
        self.assertEquals(backtick('bzr root')[:-1],
 
632
        self.assertEquals(capture('root')[:-1],
302
633
                          os.path.join(self.test_dir, 'branch1'))
303
634
        runbzr('move ../hello.txt .')
304
635
        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')
 
636
        self.assertEquals(capture('relpath hello.txt'),
 
637
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
638
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
307
639
        runbzr(['commit', '-m', 'move to parent directory'])
308
640
        chdir('..')
309
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
641
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
310
642
 
311
643
        runbzr('move sub2/hello.txt .')
312
644
        assert exists('hello.txt')
321
653
 
322
654
        runbzr('commit -F msg.tmp')
323
655
 
324
 
        assert backtick('bzr revno') == '5\n'
 
656
        assert capture('revno') == '5\n'
325
657
        runbzr('export -r 5 export-5.tmp')
326
658
        runbzr('export export.tmp')
327
659
 
329
661
        runbzr('log -v')
330
662
        runbzr('log -v --forward')
331
663
        runbzr('log -m', retcode=1)
332
 
        log_out = backtick('bzr log -m commit')
 
664
        log_out = capture('log -m commit')
333
665
        assert "this is my new commit" in log_out
334
666
        assert "rename nested" not in log_out
335
667
        assert 'revision-id' not in log_out
336
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
668
        assert 'revision-id' in capture('log --show-ids -m commit')
337
669
 
338
670
 
339
671
        progress("file with spaces in name")
349
681
 
350
682
        runbzr('info')
351
683
 
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
 
 
 
684
        if has_symlinks():
 
685
            progress("symlinks")
 
686
            mkdir('symlinks')
 
687
            chdir('symlinks')
 
688
            runbzr('init')
 
689
            os.symlink("NOWHERE1", "link1")
 
690
            runbzr('add link1')
 
691
            assert self.capture('unknowns') == ''
 
692
            runbzr(['commit', '-m', '1: added symlink link1'])
 
693
    
 
694
            mkdir('d1')
 
695
            runbzr('add d1')
 
696
            assert self.capture('unknowns') == ''
 
697
            os.symlink("NOWHERE2", "d1/link2")
 
698
            assert self.capture('unknowns') == 'd1/link2\n'
 
699
            # is d1/link2 found when adding d1
 
700
            runbzr('add d1')
 
701
            assert self.capture('unknowns') == ''
 
702
            os.symlink("NOWHERE3", "d1/link3")
 
703
            assert self.capture('unknowns') == 'd1/link3\n'
 
704
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
705
    
 
706
            runbzr('rename d1 d2')
 
707
            runbzr('move d2/link2 .')
 
708
            runbzr('move link1 d2')
 
709
            assert os.readlink("./link2") == "NOWHERE2"
 
710
            assert os.readlink("d2/link1") == "NOWHERE1"
 
711
            runbzr('add d2/link3')
 
712
            runbzr('diff')
 
713
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
714
    
 
715
            os.unlink("link2")
 
716
            os.symlink("TARGET 2", "link2")
 
717
            os.unlink("d2/link1")
 
718
            os.symlink("TARGET 1", "d2/link1")
 
719
            runbzr('diff')
 
720
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
721
            runbzr(['commit', '-m', '4: retarget of two links'])
 
722
    
 
723
            runbzr('remove d2/link1')
 
724
            assert self.capture('unknowns') == 'd2/link1\n'
 
725
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
726
            # try with the rm alias
 
727
            runbzr('add d2/link1')
 
728
            runbzr(['commit', '-m', '6: add d2/link1'])
 
729
            runbzr('rm d2/link1')
 
730
            assert self.capture('unknowns') == 'd2/link1\n'
 
731
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
732
    
 
733
            os.mkdir("d1")
 
734
            runbzr('add d1')
 
735
            runbzr('rename d2/link3 d1/link3new')
 
736
            assert self.capture('unknowns') == 'd2/link1\n'
 
737
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
738
            
 
739
            runbzr(['check'])
 
740
            
 
741
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
742
            chdir("exp1.tmp")
 
743
            assert listdir_sorted(".") == [ "link1" ]
 
744
            assert os.readlink("link1") == "NOWHERE1"
 
745
            chdir("..")
 
746
            
 
747
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
748
            chdir("exp2.tmp")
 
749
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
750
            chdir("..")
 
751
            
 
752
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
753
            chdir("exp3.tmp")
 
754
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
755
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
756
            assert os.readlink("d2/link1") == "NOWHERE1"
 
757
            assert os.readlink("link2")    == "NOWHERE2"
 
758
            chdir("..")
 
759
            
 
760
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
761
            chdir("exp4.tmp")
 
762
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
763
            assert os.readlink("d2/link1") == "TARGET 1"
 
764
            assert os.readlink("link2")    == "TARGET 2"
 
765
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
766
            chdir("..")
 
767
            
 
768
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
769
            chdir("exp5.tmp")
 
770
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
771
            assert os.path.islink("link2")
 
772
            assert listdir_sorted("d2")== [ "link3" ]
 
773
            chdir("..")
 
774
            
 
775
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
776
            chdir("exp6.tmp")
 
777
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
778
            assert listdir_sorted("d1") == [ "link3new" ]
 
779
            assert listdir_sorted("d2") == []
 
780
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
781
            chdir("..")
 
782
        else:
 
783
            progress("skipping symlink tests")
 
784
 
 
785
 
 
786
class HttpTests(TestCaseWithWebserver):
 
787
    """Test bzr ui commands against remote branches."""
 
788
 
 
789
    def test_branch(self):
 
790
        os.mkdir('from')
 
791
        branch = Branch.initialize('from')
 
792
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
793
        url = self.get_remote_url('from')
 
794
        self.run_bzr('branch', url, 'to')
 
795
        branch = Branch.open('to')
 
796
        self.assertEqual(1, len(branch.revision_history()))