/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-10 01:32:08 UTC
  • Revision ID: robertc@robertcollins.net-20051010013208-163c23746972763a
branch: namespace

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_unknown_command(self):
 
458
        """Handling of unknown command."""
 
459
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
460
                                         retcode=1)
 
461
        self.assertEquals(out, '')
 
462
        err.index('unknown command')
 
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
180
503
 
181
504
 
182
505
class OldTests(ExternalBase):
183
 
    # old tests moved from ./testbzr
184
 
    def runTest(self):
 
506
    """old tests moved from ./testbzr."""
 
507
 
 
508
    def test_bzr(self):
185
509
        from os import chdir, mkdir
186
510
        from os.path import exists
187
 
        import os
188
511
 
189
512
        runbzr = self.runbzr
190
 
        backtick = self.backtick
 
513
        capture = self.capture
191
514
        progress = self.log
192
515
 
193
516
        progress("basic branch creation")
195
518
        chdir('branch1')
196
519
        runbzr('init')
197
520
 
198
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
521
        self.assertEquals(capture('root').rstrip(),
199
522
                          os.path.join(self.test_dir, 'branch1'))
200
523
 
201
524
        progress("status of new file")
204
527
        f.write('hello world!\n')
205
528
        f.close()
206
529
 
207
 
        out = backtick("bzr unknowns")
208
 
        self.assertEquals(out, 'test.txt\n')
 
530
        self.assertEquals(capture('unknowns'), 'test.txt\n')
209
531
 
210
 
        out = backtick("bzr status")
 
532
        out = capture("status")
211
533
        assert out == 'unknown:\n  test.txt\n'
212
534
 
213
 
        out = backtick("bzr status --all")
 
535
        out = capture("status --all")
214
536
        assert out == "unknown:\n  test.txt\n"
215
537
 
216
 
        out = backtick("bzr status test.txt --all")
 
538
        out = capture("status test.txt --all")
217
539
        assert out == "unknown:\n  test.txt\n"
218
540
 
219
541
        f = file('test2.txt', 'wt')
220
542
        f.write('goodbye cruel world...\n')
221
543
        f.close()
222
544
 
223
 
        out = backtick("bzr status test.txt")
 
545
        out = capture("status test.txt")
224
546
        assert out == "unknown:\n  test.txt\n"
225
547
 
226
 
        out = backtick("bzr status")
 
548
        out = capture("status")
227
549
        assert out == ("unknown:\n"
228
550
                       "  test.txt\n"
229
551
                       "  test2.txt\n")
231
553
        os.unlink('test2.txt')
232
554
 
233
555
        progress("command aliases")
234
 
        out = backtick("bzr st --all")
 
556
        out = capture("st --all")
235
557
        assert out == ("unknown:\n"
236
558
                       "  test.txt\n")
237
559
 
238
 
        out = backtick("bzr stat")
 
560
        out = capture("stat")
239
561
        assert out == ("unknown:\n"
240
562
                       "  test.txt\n")
241
563
 
245
567
        runbzr("help commands")
246
568
        runbzr("help slartibartfast", 1)
247
569
 
248
 
        out = backtick("bzr help ci")
 
570
        out = capture("help ci")
249
571
        out.index('aliases: ')
250
572
 
251
573
        progress("can't rename unversioned file")
254
576
        progress("adding a file")
255
577
 
256
578
        runbzr("add test.txt")
257
 
        assert backtick("bzr unknowns") == ''
258
 
        assert backtick("bzr status --all") == ("added:\n"
 
579
        assert capture("unknowns") == ''
 
580
        assert capture("status --all") == ("added:\n"
259
581
                                                "  test.txt\n")
260
582
 
261
583
        progress("rename newly-added file")
263
585
        assert os.path.exists("hello.txt")
264
586
        assert not os.path.exists("test.txt")
265
587
 
266
 
        assert backtick("bzr revno") == '0\n'
 
588
        assert capture("revno") == '0\n'
267
589
 
268
590
        progress("add first revision")
269
591
        runbzr(['commit', '-m', 'add first revision'])
277
599
        runbzr("add sub1")
278
600
        runbzr("rename sub1 sub2")
279
601
        runbzr("move hello.txt sub2")
280
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
602
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
281
603
 
282
604
        assert exists("sub2")
283
605
        assert exists("sub2/hello.txt")
298
620
        runbzr(['commit', '-m', 'rename nested subdirectories'])
299
621
 
300
622
        chdir('sub1/sub2')
301
 
        self.assertEquals(backtick('bzr root')[:-1],
 
623
        self.assertEquals(capture('root')[:-1],
302
624
                          os.path.join(self.test_dir, 'branch1'))
303
625
        runbzr('move ../hello.txt .')
304
626
        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')
 
627
        self.assertEquals(capture('relpath hello.txt'),
 
628
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
629
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
307
630
        runbzr(['commit', '-m', 'move to parent directory'])
308
631
        chdir('..')
309
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
632
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
310
633
 
311
634
        runbzr('move sub2/hello.txt .')
312
635
        assert exists('hello.txt')
321
644
 
322
645
        runbzr('commit -F msg.tmp')
323
646
 
324
 
        assert backtick('bzr revno') == '5\n'
 
647
        assert capture('revno') == '5\n'
325
648
        runbzr('export -r 5 export-5.tmp')
326
649
        runbzr('export export.tmp')
327
650
 
329
652
        runbzr('log -v')
330
653
        runbzr('log -v --forward')
331
654
        runbzr('log -m', retcode=1)
332
 
        log_out = backtick('bzr log -m commit')
 
655
        log_out = capture('log -m commit')
333
656
        assert "this is my new commit" in log_out
334
657
        assert "rename nested" not in log_out
335
658
        assert 'revision-id' not in log_out
336
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
659
        assert 'revision-id' in capture('log --show-ids -m commit')
337
660
 
338
661
 
339
662
        progress("file with spaces in name")
349
672
 
350
673
        runbzr('info')
351
674
 
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
 
 
 
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()))