/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

Merge in format-5 work - release bzr 0.1rc1.

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.errors import BzrCommandError
 
35
from bzrlib.osutils import has_symlinks
 
36
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
37
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
 
38
 
 
39
 
 
40
class ExternalBase(TestCaseInTempDir):
 
41
 
 
42
    def runbzr(self, args, retcode=0, backtick=False):
44
43
        if isinstance(args, basestring):
45
44
            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):
 
45
 
 
46
        if backtick:
 
47
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
48
        else:
 
49
            return self.run_bzr_captured(args, retcode=retcode)
 
50
 
 
51
 
 
52
class TestCommands(ExternalBase):
 
53
 
 
54
    def test_help_commands(self):
105
55
        self.runbzr('--help')
106
56
        self.runbzr('help')
107
57
        self.runbzr('help commands')
108
58
        self.runbzr('help help')
109
59
        self.runbzr('commit -h')
110
60
 
111
 
 
112
 
class InitBranch(ExternalBase):
113
 
    def runTest(self):
114
 
        import os
 
61
    def test_init_branch(self):
115
62
        self.runbzr(['init'])
116
63
 
117
 
 
118
 
 
119
 
class UserIdentity(ExternalBase):
120
 
    def runTest(self):
 
64
    def test_whoami(self):
121
65
        # this should always identify something, if only "john@localhost"
122
66
        self.runbzr("whoami")
123
67
        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):
 
68
 
 
69
        self.assertEquals(self.runbzr("whoami --email",
 
70
                                      backtick=True).count('@'), 1)
 
71
        
 
72
    def test_whoami_branch(self):
 
73
        """branch specific user identity works."""
 
74
        self.runbzr('init')
 
75
        f = file('.bzr/email', 'wt')
 
76
        f.write('Branch Identity <branch@identi.ty>')
 
77
        f.close()
 
78
        bzr_email = os.environ.get('BZREMAIL')
 
79
        if bzr_email is not None:
 
80
            del os.environ['BZREMAIL']
 
81
        whoami = self.runbzr("whoami",backtick=True)
 
82
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
83
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
84
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
85
        # Verify that the environment variable overrides the value 
 
86
        # in the file
 
87
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
88
        whoami = self.runbzr("whoami",backtick=True)
 
89
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
90
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
91
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
92
        if bzr_email is not None:
 
93
            os.environ['BZREMAIL'] = bzr_email
 
94
 
 
95
    def test_invalid_commands(self):
130
96
        self.runbzr("pants", retcode=1)
131
97
        self.runbzr("--pants off", retcode=1)
132
98
        self.runbzr("diff --message foo", retcode=1)
133
99
 
134
 
 
135
 
 
136
 
class EmptyCommit(ExternalBase):
137
 
    def runTest(self):
 
100
    def test_empty_commit(self):
138
101
        self.runbzr("init")
139
102
        self.build_tree(['hello.txt'])
140
103
        self.runbzr("commit -m empty", retcode=1)
141
104
        self.runbzr("add hello.txt")
142
105
        self.runbzr("commit -m added")
143
106
 
144
 
 
145
 
 
146
 
class IgnorePatterns(ExternalBase):
147
 
    def runTest(self):
 
107
    def test_empty_commit_message(self):
 
108
        self.runbzr("init")
 
109
        file('foo.c', 'wt').write('int main() {}')
 
110
        self.runbzr(['add', 'foo.c'])
 
111
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
112
 
 
113
    def test_ignore_patterns(self):
148
114
        from bzrlib.branch import Branch
149
115
        
150
 
        b = Branch('.', init=True)
 
116
        b = Branch.initialize('.')
151
117
        self.assertEquals(list(b.unknowns()), [])
152
118
 
153
119
        file('foo.tmp', 'wt').write('tmp files are ignored')
154
120
        self.assertEquals(list(b.unknowns()), [])
155
 
        assert self.backtick('bzr unknowns') == ''
 
121
        assert self.capture('unknowns') == ''
156
122
 
157
123
        file('foo.c', 'wt').write('int main() {}')
158
124
        self.assertEquals(list(b.unknowns()), ['foo.c'])
159
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
125
        assert self.capture('unknowns') == 'foo.c\n'
160
126
 
161
127
        self.runbzr(['add', 'foo.c'])
162
 
        assert self.backtick('bzr unknowns') == ''
 
128
        assert self.capture('unknowns') == ''
163
129
 
164
130
        # 'ignore' works when creating the .bzignore file
165
131
        file('foo.blah', 'wt').write('blah')
166
132
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
167
133
        self.runbzr('ignore *.blah')
168
134
        self.assertEquals(list(b.unknowns()), [])
169
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
170
136
 
171
137
        # 'ignore' works when then .bzrignore file already exists
172
138
        file('garh', 'wt').write('garh')
173
139
        self.assertEquals(list(b.unknowns()), ['garh'])
174
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
140
        assert self.capture('unknowns') == 'garh\n'
175
141
        self.runbzr('ignore garh')
176
142
        self.assertEquals(list(b.unknowns()), [])
177
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
178
 
        
179
 
 
 
143
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
144
 
 
145
    def test_revert(self):
 
146
        self.runbzr('init')
 
147
 
 
148
        file('hello', 'wt').write('foo')
 
149
        self.runbzr('add hello')
 
150
        self.runbzr('commit -m setup hello')
 
151
 
 
152
        file('goodbye', 'wt').write('baz')
 
153
        self.runbzr('add goodbye')
 
154
        self.runbzr('commit -m setup goodbye')
 
155
 
 
156
        file('hello', 'wt').write('bar')
 
157
        file('goodbye', 'wt').write('qux')
 
158
        self.runbzr('revert hello')
 
159
        self.check_file_contents('hello', 'foo')
 
160
        self.check_file_contents('goodbye', 'qux')
 
161
        self.runbzr('revert')
 
162
        self.check_file_contents('goodbye', 'baz')
 
163
 
 
164
        os.mkdir('revertdir')
 
165
        self.runbzr('add revertdir')
 
166
        self.runbzr('commit -m f')
 
167
        os.rmdir('revertdir')
 
168
        self.runbzr('revert')
 
169
 
 
170
        os.symlink('/unlikely/to/exist', 'symlink')
 
171
        self.runbzr('add symlink')
 
172
        self.runbzr('commit -m f')
 
173
        os.unlink('symlink')
 
174
        self.runbzr('revert')
 
175
        
 
176
        file('hello', 'wt').write('xyz')
 
177
        self.runbzr('commit -m xyz hello')
 
178
        self.runbzr('revert -r 1 hello')
 
179
        self.check_file_contents('hello', 'foo')
 
180
        self.runbzr('revert hello')
 
181
        self.check_file_contents('hello', 'xyz')
 
182
        os.chdir('revertdir')
 
183
        self.runbzr('revert')
 
184
        os.chdir('..')
 
185
 
 
186
 
 
187
    def test_mv_modes(self):
 
188
        """Test two modes of operation for mv"""
 
189
        from bzrlib.branch import Branch
 
190
        b = Branch.initialize('.')
 
191
        self.build_tree(['a', 'c', 'subdir/'])
 
192
        self.run_bzr_captured(['add', self.test_dir])
 
193
        self.run_bzr_captured(['mv', 'a', 'b'])
 
194
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
195
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
196
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
197
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
198
 
 
199
    def test_main_version(self):
 
200
        """Check output from version command and master option is reasonable"""
 
201
        # output is intentionally passed through to stdout so that we
 
202
        # can see the version being tested
 
203
        output = self.runbzr('version', backtick=1)
 
204
        self.log('bzr version output:')
 
205
        self.log(output)
 
206
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
207
        self.assertNotEqual(output.index('Canonical'), -1)
 
208
        # make sure --version is consistent
 
209
        tmp_output = self.runbzr('--version', backtick=1)
 
210
        self.log('bzr --version output:')
 
211
        self.log(tmp_output)
 
212
        self.assertEquals(output, tmp_output)
 
213
 
 
214
    def example_branch(test):
 
215
        test.runbzr('init')
 
216
        file('hello', 'wt').write('foo')
 
217
        test.runbzr('add hello')
 
218
        test.runbzr('commit -m setup hello')
 
219
        file('goodbye', 'wt').write('baz')
 
220
        test.runbzr('add goodbye')
 
221
        test.runbzr('commit -m setup goodbye')
 
222
 
 
223
    def test_export(self):
 
224
        os.mkdir('branch')
 
225
        os.chdir('branch')
 
226
        self.example_branch()
 
227
        self.runbzr('export ../latest')
 
228
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
229
        self.runbzr('export ../first -r 1')
 
230
        assert not os.path.exists('../first/goodbye')
 
231
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
232
        self.runbzr('export ../first.gz -r 1')
 
233
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
234
        self.runbzr('export ../first.bz2 -r 1')
 
235
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
236
        self.runbzr('export ../first.tar -r 1')
 
237
        assert os.path.isfile('../first.tar')
 
238
        from tarfile import TarFile
 
239
        tf = TarFile('../first.tar')
 
240
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
241
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
242
        self.runbzr('export ../first.tar.gz -r 1')
 
243
        assert os.path.isfile('../first.tar.gz')
 
244
        self.runbzr('export ../first.tbz2 -r 1')
 
245
        assert os.path.isfile('../first.tbz2')
 
246
        self.runbzr('export ../first.tar.bz2 -r 1')
 
247
        assert os.path.isfile('../first.tar.bz2')
 
248
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
249
        assert os.path.isfile('../first.tar.tbz2')
 
250
        from bz2 import BZ2File
 
251
        tf = TarFile('../first.tar.tbz2', 
 
252
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
253
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
254
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
255
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
256
        tf = TarFile('../first2.tar')
 
257
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
258
 
 
259
    def test_diff(self):
 
260
        self.example_branch()
 
261
        file('hello', 'wt').write('hello world!')
 
262
        self.runbzr('commit -m fixing hello')
 
263
        output = self.runbzr('diff -r 2..3', backtick=1)
 
264
        self.assert_('\n+hello world!' in output)
 
265
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
266
        self.assert_('\n+baz' in output)
 
267
 
 
268
    def test_branch(self):
 
269
        """Branch from one branch to another."""
 
270
        os.mkdir('a')
 
271
        os.chdir('a')
 
272
        self.example_branch()
 
273
        os.chdir('..')
 
274
        self.runbzr('branch a b')
 
275
        self.runbzr('branch a c -r 1')
 
276
        os.chdir('b')
 
277
        self.runbzr('commit -m foo --unchanged')
 
278
        os.chdir('..')
 
279
        # naughty - abstraction violations RBC 20050928  
 
280
        print "test_branch used to delete the stores, how is this meant to work ?"
 
281
        #shutil.rmtree('a/.bzr/revision-store')
 
282
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
283
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
284
        self.runbzr('branch a d --basis b')
 
285
 
 
286
    def test_merge(self):
 
287
        from bzrlib.branch import Branch
 
288
        
 
289
        os.mkdir('a')
 
290
        os.chdir('a')
 
291
        self.example_branch()
 
292
        os.chdir('..')
 
293
        self.runbzr('branch a b')
 
294
        os.chdir('b')
 
295
        file('goodbye', 'wt').write('quux')
 
296
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
297
 
 
298
        os.chdir('../a')
 
299
        file('hello', 'wt').write('quuux')
 
300
        # We can't merge when there are in-tree changes
 
301
        self.runbzr('merge ../b', retcode=1)
 
302
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
303
        self.runbzr('merge ../b')
 
304
        self.check_file_contents('goodbye', 'quux')
 
305
        # Merging a branch pulls its revision into the tree
 
306
        a = Branch.open('.')
 
307
        b = Branch.open('../b')
 
308
        a.get_revision_xml(b.last_revision())
 
309
        self.log('pending merges: %s', a.pending_merges())
 
310
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
311
        #        % (a.pending_merges(), b.last_revision())
 
312
 
 
313
    def test_merge_with_missing_file(self):
 
314
        """Merge handles missing file conflicts"""
 
315
        os.mkdir('a')
 
316
        os.chdir('a')
 
317
        os.mkdir('sub')
 
318
        print >> file('sub/a.txt', 'wb'), "hello"
 
319
        print >> file('b.txt', 'wb'), "hello"
 
320
        print >> file('sub/c.txt', 'wb'), "hello"
 
321
        self.runbzr('init')
 
322
        self.runbzr('add')
 
323
        self.runbzr(('commit', '-m', 'added a'))
 
324
        self.runbzr('branch . ../b')
 
325
        print >> file('sub/a.txt', 'ab'), "there"
 
326
        print >> file('b.txt', 'ab'), "there"
 
327
        print >> file('sub/c.txt', 'ab'), "there"
 
328
        self.runbzr(('commit', '-m', 'Added there'))
 
329
        os.unlink('sub/a.txt')
 
330
        os.unlink('sub/c.txt')
 
331
        os.rmdir('sub')
 
332
        os.unlink('b.txt')
 
333
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
334
        os.chdir('../b')
 
335
        print >> file('sub/a.txt', 'ab'), "something"
 
336
        print >> file('b.txt', 'ab'), "something"
 
337
        print >> file('sub/c.txt', 'ab'), "something"
 
338
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
339
        self.runbzr('merge ../a/')
 
340
        assert os.path.exists('sub/a.txt.THIS')
 
341
        assert os.path.exists('sub/a.txt.BASE')
 
342
        os.chdir('../a')
 
343
        self.runbzr('merge ../b/')
 
344
        assert os.path.exists('sub/a.txt.OTHER')
 
345
        assert os.path.exists('sub/a.txt.BASE')
 
346
 
 
347
    def test_pull(self):
 
348
        """Pull changes from one branch to another."""
 
349
        os.mkdir('a')
 
350
        os.chdir('a')
 
351
 
 
352
        self.example_branch()
 
353
        self.runbzr('pull', retcode=1)
 
354
        self.runbzr('missing', retcode=1)
 
355
        self.runbzr('missing .')
 
356
        self.runbzr('missing')
 
357
        self.runbzr('pull')
 
358
        self.runbzr('pull /', retcode=1)
 
359
        self.runbzr('pull')
 
360
 
 
361
        os.chdir('..')
 
362
        self.runbzr('branch a b')
 
363
        os.chdir('b')
 
364
        self.runbzr('pull')
 
365
        os.mkdir('subdir')
 
366
        self.runbzr('add subdir')
 
367
        self.runbzr('commit -m blah --unchanged')
 
368
        os.chdir('../a')
 
369
        a = Branch.open('.')
 
370
        b = Branch.open('../b')
 
371
        assert a.revision_history() == b.revision_history()[:-1]
 
372
        self.runbzr('pull ../b')
 
373
        assert a.revision_history() == b.revision_history()
 
374
        self.runbzr('commit -m blah2 --unchanged')
 
375
        os.chdir('../b')
 
376
        self.runbzr('commit -m blah3 --unchanged')
 
377
        self.runbzr('pull ../a', retcode=1)
 
378
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
379
        return
 
380
        os.chdir('../a')
 
381
        self.runbzr('merge ../b')
 
382
        self.runbzr('commit -m blah4 --unchanged')
 
383
        os.chdir('../b/subdir')
 
384
        self.runbzr('pull ../../a')
 
385
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
386
        self.runbzr('commit -m blah5 --unchanged')
 
387
        self.runbzr('commit -m blah6 --unchanged')
 
388
        os.chdir('..')
 
389
        self.runbzr('pull ../a')
 
390
        os.chdir('../a')
 
391
        self.runbzr('commit -m blah7 --unchanged')
 
392
        self.runbzr('merge ../b')
 
393
        self.runbzr('commit -m blah8 --unchanged')
 
394
        self.runbzr('pull ../b')
 
395
        self.runbzr('pull ../b')
 
396
        
 
397
    def test_add_reports(self):
 
398
        """add command prints the names of added files."""
 
399
        b = Branch.initialize('.')
 
400
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
401
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
402
        # the ordering is not defined at the moment
 
403
        results = sorted(out.rstrip('\n').split('\n'))
 
404
        self.assertEquals(['added dir',
 
405
                           'added dir'+os.sep+'sub.txt',
 
406
                           'added top.txt',],
 
407
                          results)
 
408
 
 
409
    def test_unknown_command(self):
 
410
        """Handling of unknown command."""
 
411
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
412
                                         retcode=1)
 
413
        self.assertEquals(out, '')
 
414
        err.index('unknown command')
 
415
 
 
416
 
 
417
def listdir_sorted(dir):
 
418
    L = os.listdir(dir)
 
419
    L.sort()
 
420
    return L
180
421
 
181
422
 
182
423
class OldTests(ExternalBase):
183
 
    # old tests moved from ./testbzr
184
 
    def runTest(self):
 
424
    """old tests moved from ./testbzr."""
 
425
 
 
426
    def test_bzr(self):
185
427
        from os import chdir, mkdir
186
428
        from os.path import exists
187
 
        import os
188
429
 
189
430
        runbzr = self.runbzr
190
 
        backtick = self.backtick
 
431
        capture = self.capture
191
432
        progress = self.log
192
433
 
193
434
        progress("basic branch creation")
195
436
        chdir('branch1')
196
437
        runbzr('init')
197
438
 
198
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
439
        self.assertEquals(capture('root').rstrip(),
199
440
                          os.path.join(self.test_dir, 'branch1'))
200
441
 
201
442
        progress("status of new file")
204
445
        f.write('hello world!\n')
205
446
        f.close()
206
447
 
207
 
        out = backtick("bzr unknowns")
208
 
        self.assertEquals(out, 'test.txt\n')
 
448
        self.assertEquals(capture('unknowns'), 'test.txt\n')
209
449
 
210
 
        out = backtick("bzr status")
 
450
        out = capture("status")
211
451
        assert out == 'unknown:\n  test.txt\n'
212
452
 
213
 
        out = backtick("bzr status --all")
 
453
        out = capture("status --all")
214
454
        assert out == "unknown:\n  test.txt\n"
215
455
 
216
 
        out = backtick("bzr status test.txt --all")
 
456
        out = capture("status test.txt --all")
217
457
        assert out == "unknown:\n  test.txt\n"
218
458
 
219
459
        f = file('test2.txt', 'wt')
220
460
        f.write('goodbye cruel world...\n')
221
461
        f.close()
222
462
 
223
 
        out = backtick("bzr status test.txt")
 
463
        out = capture("status test.txt")
224
464
        assert out == "unknown:\n  test.txt\n"
225
465
 
226
 
        out = backtick("bzr status")
 
466
        out = capture("status")
227
467
        assert out == ("unknown:\n"
228
468
                       "  test.txt\n"
229
469
                       "  test2.txt\n")
231
471
        os.unlink('test2.txt')
232
472
 
233
473
        progress("command aliases")
234
 
        out = backtick("bzr st --all")
 
474
        out = capture("st --all")
235
475
        assert out == ("unknown:\n"
236
476
                       "  test.txt\n")
237
477
 
238
 
        out = backtick("bzr stat")
 
478
        out = capture("stat")
239
479
        assert out == ("unknown:\n"
240
480
                       "  test.txt\n")
241
481
 
245
485
        runbzr("help commands")
246
486
        runbzr("help slartibartfast", 1)
247
487
 
248
 
        out = backtick("bzr help ci")
 
488
        out = capture("help ci")
249
489
        out.index('aliases: ')
250
490
 
251
491
        progress("can't rename unversioned file")
254
494
        progress("adding a file")
255
495
 
256
496
        runbzr("add test.txt")
257
 
        assert backtick("bzr unknowns") == ''
258
 
        assert backtick("bzr status --all") == ("added:\n"
 
497
        assert capture("unknowns") == ''
 
498
        assert capture("status --all") == ("added:\n"
259
499
                                                "  test.txt\n")
260
500
 
261
501
        progress("rename newly-added file")
263
503
        assert os.path.exists("hello.txt")
264
504
        assert not os.path.exists("test.txt")
265
505
 
266
 
        assert backtick("bzr revno") == '0\n'
 
506
        assert capture("revno") == '0\n'
267
507
 
268
508
        progress("add first revision")
269
509
        runbzr(['commit', '-m', 'add first revision'])
277
517
        runbzr("add sub1")
278
518
        runbzr("rename sub1 sub2")
279
519
        runbzr("move hello.txt sub2")
280
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
520
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
281
521
 
282
522
        assert exists("sub2")
283
523
        assert exists("sub2/hello.txt")
298
538
        runbzr(['commit', '-m', 'rename nested subdirectories'])
299
539
 
300
540
        chdir('sub1/sub2')
301
 
        self.assertEquals(backtick('bzr root')[:-1],
 
541
        self.assertEquals(capture('root')[:-1],
302
542
                          os.path.join(self.test_dir, 'branch1'))
303
543
        runbzr('move ../hello.txt .')
304
544
        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')
 
545
        self.assertEquals(capture('relpath hello.txt'),
 
546
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
547
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
307
548
        runbzr(['commit', '-m', 'move to parent directory'])
308
549
        chdir('..')
309
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
550
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
310
551
 
311
552
        runbzr('move sub2/hello.txt .')
312
553
        assert exists('hello.txt')
321
562
 
322
563
        runbzr('commit -F msg.tmp')
323
564
 
324
 
        assert backtick('bzr revno') == '5\n'
 
565
        assert capture('revno') == '5\n'
325
566
        runbzr('export -r 5 export-5.tmp')
326
567
        runbzr('export export.tmp')
327
568
 
329
570
        runbzr('log -v')
330
571
        runbzr('log -v --forward')
331
572
        runbzr('log -m', retcode=1)
332
 
        log_out = backtick('bzr log -m commit')
 
573
        log_out = capture('log -m commit')
333
574
        assert "this is my new commit" in log_out
334
575
        assert "rename nested" not in log_out
335
576
        assert 'revision-id' not in log_out
336
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
577
        assert 'revision-id' in capture('log --show-ids -m commit')
337
578
 
338
579
 
339
580
        progress("file with spaces in name")
349
590
 
350
591
        runbzr('info')
351
592
 
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
 
 
 
593
        if has_symlinks():
 
594
            progress("symlinks")
 
595
            mkdir('symlinks')
 
596
            chdir('symlinks')
 
597
            runbzr('init')
 
598
            os.symlink("NOWHERE1", "link1")
 
599
            runbzr('add link1')
 
600
            assert self.capture('unknowns') == ''
 
601
            runbzr(['commit', '-m', '1: added symlink link1'])
 
602
    
 
603
            mkdir('d1')
 
604
            runbzr('add d1')
 
605
            assert self.capture('unknowns') == ''
 
606
            os.symlink("NOWHERE2", "d1/link2")
 
607
            assert self.capture('unknowns') == 'd1/link2\n'
 
608
            # is d1/link2 found when adding d1
 
609
            runbzr('add d1')
 
610
            assert self.capture('unknowns') == ''
 
611
            os.symlink("NOWHERE3", "d1/link3")
 
612
            assert self.capture('unknowns') == 'd1/link3\n'
 
613
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
614
    
 
615
            runbzr('rename d1 d2')
 
616
            runbzr('move d2/link2 .')
 
617
            runbzr('move link1 d2')
 
618
            assert os.readlink("./link2") == "NOWHERE2"
 
619
            assert os.readlink("d2/link1") == "NOWHERE1"
 
620
            runbzr('add d2/link3')
 
621
            runbzr('diff')
 
622
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
623
    
 
624
            os.unlink("link2")
 
625
            os.symlink("TARGET 2", "link2")
 
626
            os.unlink("d2/link1")
 
627
            os.symlink("TARGET 1", "d2/link1")
 
628
            runbzr('diff')
 
629
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
630
            runbzr(['commit', '-m', '4: retarget of two links'])
 
631
    
 
632
            runbzr('remove d2/link1')
 
633
            assert self.capture('unknowns') == 'd2/link1\n'
 
634
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
635
    
 
636
            os.mkdir("d1")
 
637
            runbzr('add d1')
 
638
            runbzr('rename d2/link3 d1/link3new')
 
639
            assert self.capture('unknowns') == 'd2/link1\n'
 
640
            runbzr(['commit', '-m', '6: remove d2/link1, move/rename link3'])
 
641
            
 
642
            runbzr(['check'])
 
643
            
 
644
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
645
            chdir("exp1.tmp")
 
646
            assert listdir_sorted(".") == [ "link1" ]
 
647
            assert os.readlink("link1") == "NOWHERE1"
 
648
            chdir("..")
 
649
            
 
650
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
651
            chdir("exp2.tmp")
 
652
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
653
            chdir("..")
 
654
            
 
655
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
656
            chdir("exp3.tmp")
 
657
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
658
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
659
            assert os.readlink("d2/link1") == "NOWHERE1"
 
660
            assert os.readlink("link2")    == "NOWHERE2"
 
661
            chdir("..")
 
662
            
 
663
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
664
            chdir("exp4.tmp")
 
665
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
666
            assert os.readlink("d2/link1") == "TARGET 1"
 
667
            assert os.readlink("link2")    == "TARGET 2"
 
668
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
669
            chdir("..")
 
670
            
 
671
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
672
            chdir("exp5.tmp")
 
673
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
674
            assert os.path.islink("link2")
 
675
            assert listdir_sorted("d2")== [ "link3" ]
 
676
            chdir("..")
 
677
            
 
678
            runbzr(['export', '-r', '6', 'exp6.tmp'])
 
679
            chdir("exp6.tmp")
 
680
            assert listdir_sorted(".") == [ "d1", "d2", "link2" ]
 
681
            assert listdir_sorted("d1") == [ "link3new" ]
 
682
            assert listdir_sorted("d2") == []
 
683
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
684
            chdir("..")
 
685
        else:
 
686
            progress("skipping symlink tests")
 
687
 
 
688
 
 
689
class HttpTests(TestCaseWithWebserver):
 
690
    """Test bzr ui commands against remote branches."""
 
691
 
 
692
    def test_branch(self):
 
693
        os.mkdir('from')
 
694
        branch = Branch.initialize('from')
 
695
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
696
        url = self.get_remote_url('from')
 
697
        self.run_bzr('branch', url, 'to')
 
698
        branch = Branch.open('to')
 
699
        self.assertEqual(1, len(branch.revision_history()))