/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-02 21:51:29 UTC
  • mfrom: (1396)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20051002215128-5686c7d24bf9bdb9
merge from martins newformat branch - brings in transport abstraction

Show diffs side-by-side

added added

removed removed

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