/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: Aaron Bentley
  • Date: 2005-10-01 06:48:01 UTC
  • mto: (1185.12.13)
  • mto: This revision was merged to the branch mainline in revision 1419.
  • Revision ID: aaron.bentley@utoronto.ca-20051001064801-7400c2ed0fe26080
Made iter_conflicts a WorkingTree method

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
3
 
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
 
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
 
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
 
 
19
"""Black-box tests for bzr.
 
20
 
 
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.
 
27
"""
 
28
 
 
29
from cStringIO import StringIO
 
30
import os
 
31
import shutil
 
32
import sys
 
33
 
 
34
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
35
from bzrlib.branch import Branch
 
36
 
 
37
 
 
38
class ExternalBase(TestCaseInTempDir):
 
39
 
 
40
    def runbzr(self, args, retcode=0, backtick=False):
 
41
        if isinstance(args, basestring):
 
42
            args = args.split()
 
43
 
 
44
        if backtick:
 
45
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
46
        else:
 
47
            return self.run_bzr_captured(args, retcode=retcode)
 
48
 
 
49
 
 
50
class TestCommands(ExternalBase):
 
51
 
 
52
    def test_help_commands(self):
 
53
        self.runbzr('--help')
 
54
        self.runbzr('help')
 
55
        self.runbzr('help commands')
 
56
        self.runbzr('help help')
 
57
        self.runbzr('commit -h')
 
58
 
 
59
    def test_init_branch(self):
 
60
        self.runbzr(['init'])
 
61
 
 
62
    def test_whoami(self):
 
63
        # this should always identify something, if only "john@localhost"
 
64
        self.runbzr("whoami")
 
65
        self.runbzr("whoami --email")
 
66
 
 
67
        self.assertEquals(self.runbzr("whoami --email",
 
68
                                      backtick=True).count('@'), 1)
 
69
        
 
70
    def test_whoami_branch(self):
 
71
        """branch specific user identity works."""
 
72
        self.runbzr('init')
 
73
        f = file('.bzr/email', 'wt')
 
74
        f.write('Branch Identity <branch@identi.ty>')
 
75
        f.close()
 
76
        bzr_email = os.environ.get('BZREMAIL')
 
77
        if bzr_email is not None:
 
78
            del os.environ['BZREMAIL']
 
79
        whoami = self.runbzr("whoami",backtick=True)
 
80
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
81
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
82
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
83
        # Verify that the environment variable overrides the value 
 
84
        # in the file
 
85
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
86
        whoami = self.runbzr("whoami",backtick=True)
 
87
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
88
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
89
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
90
        if bzr_email is not None:
 
91
            os.environ['BZREMAIL'] = bzr_email
 
92
 
 
93
    def test_invalid_commands(self):
 
94
        self.runbzr("pants", retcode=1)
 
95
        self.runbzr("--pants off", retcode=1)
 
96
        self.runbzr("diff --message foo", retcode=1)
 
97
 
 
98
    def test_empty_commit(self):
 
99
        self.runbzr("init")
 
100
        self.build_tree(['hello.txt'])
 
101
        self.runbzr("commit -m empty", retcode=1)
 
102
        self.runbzr("add hello.txt")
 
103
        self.runbzr("commit -m added")
 
104
 
 
105
    def test_ignore_patterns(self):
 
106
        from bzrlib.branch import Branch
 
107
        
 
108
        b = Branch.initialize('.')
 
109
        self.assertEquals(list(b.unknowns()), [])
 
110
 
 
111
        file('foo.tmp', 'wt').write('tmp files are ignored')
 
112
        self.assertEquals(list(b.unknowns()), [])
 
113
        assert self.capture('unknowns') == ''
 
114
 
 
115
        file('foo.c', 'wt').write('int main() {}')
 
116
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
117
        assert self.capture('unknowns') == 'foo.c\n'
 
118
 
 
119
        self.runbzr(['add', 'foo.c'])
 
120
        assert self.capture('unknowns') == ''
 
121
 
 
122
        # 'ignore' works when creating the .bzignore file
 
123
        file('foo.blah', 'wt').write('blah')
 
124
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
 
125
        self.runbzr('ignore *.blah')
 
126
        self.assertEquals(list(b.unknowns()), [])
 
127
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
128
 
 
129
        # 'ignore' works when then .bzrignore file already exists
 
130
        file('garh', 'wt').write('garh')
 
131
        self.assertEquals(list(b.unknowns()), ['garh'])
 
132
        assert self.capture('unknowns') == 'garh\n'
 
133
        self.runbzr('ignore garh')
 
134
        self.assertEquals(list(b.unknowns()), [])
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
136
 
 
137
    def test_revert(self):
 
138
        self.runbzr('init')
 
139
 
 
140
        file('hello', 'wt').write('foo')
 
141
        self.runbzr('add hello')
 
142
        self.runbzr('commit -m setup hello')
 
143
 
 
144
        file('goodbye', 'wt').write('baz')
 
145
        self.runbzr('add goodbye')
 
146
        self.runbzr('commit -m setup goodbye')
 
147
        
 
148
        file('hello', 'wt').write('bar')
 
149
        file('goodbye', 'wt').write('qux')
 
150
        self.runbzr('revert hello')
 
151
        self.check_file_contents('hello', 'foo')
 
152
        self.check_file_contents('goodbye', 'qux')
 
153
        self.runbzr('revert')
 
154
        self.check_file_contents('goodbye', 'baz')
 
155
 
 
156
        os.mkdir('revertdir')
 
157
        self.runbzr('add revertdir')
 
158
        self.runbzr('commit -m f')
 
159
        os.rmdir('revertdir')
 
160
        self.runbzr('revert')
 
161
 
 
162
        file('hello', 'wt').write('xyz')
 
163
        self.runbzr('commit -m xyz hello')
 
164
        self.runbzr('revert -r 1 hello')
 
165
        self.check_file_contents('hello', 'foo')
 
166
        self.runbzr('revert hello')
 
167
        self.check_file_contents('hello', 'xyz')
 
168
        os.chdir('revertdir')
 
169
        self.runbzr('revert')
 
170
        os.chdir('..')
 
171
 
 
172
 
 
173
    def test_mv_modes(self):
 
174
        """Test two modes of operation for mv"""
 
175
        from bzrlib.branch import Branch
 
176
        b = Branch.initialize('.')
 
177
        self.build_tree(['a', 'c', 'subdir/'])
 
178
        self.run_bzr_captured(['add', self.test_dir])
 
179
        self.run_bzr_captured(['mv', 'a', 'b'])
 
180
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
181
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
182
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
183
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
184
 
 
185
 
 
186
    def test_main_version(self):
 
187
        """Check output from version command and master option is reasonable"""
 
188
        # output is intentionally passed through to stdout so that we
 
189
        # can see the version being tested
 
190
        output = self.runbzr('version', backtick=1)
 
191
        self.log('bzr version output:')
 
192
        self.log(output)
 
193
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
194
        self.assertNotEqual(output.index('Canonical'), -1)
 
195
        # make sure --version is consistent
 
196
        tmp_output = self.runbzr('--version', backtick=1)
 
197
        self.log('bzr --version output:')
 
198
        self.log(tmp_output)
 
199
        self.assertEquals(output, tmp_output)
 
200
 
 
201
    def example_branch(test):
 
202
        test.runbzr('init')
 
203
        file('hello', 'wt').write('foo')
 
204
        test.runbzr('add hello')
 
205
        test.runbzr('commit -m setup hello')
 
206
        file('goodbye', 'wt').write('baz')
 
207
        test.runbzr('add goodbye')
 
208
        test.runbzr('commit -m setup goodbye')
 
209
 
 
210
    def test_export(self):
 
211
        os.mkdir('branch')
 
212
        os.chdir('branch')
 
213
        self.example_branch()
 
214
        self.runbzr('export ../latest')
 
215
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
216
        self.runbzr('export ../first -r 1')
 
217
        assert not os.path.exists('../first/goodbye')
 
218
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
219
        self.runbzr('export ../first.gz -r 1')
 
220
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
221
        self.runbzr('export ../first.bz2 -r 1')
 
222
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
223
        self.runbzr('export ../first.tar -r 1')
 
224
        assert os.path.isfile('../first.tar')
 
225
        from tarfile import TarFile
 
226
        tf = TarFile('../first.tar')
 
227
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
228
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
229
        self.runbzr('export ../first.tar.gz -r 1')
 
230
        assert os.path.isfile('../first.tar.gz')
 
231
        self.runbzr('export ../first.tbz2 -r 1')
 
232
        assert os.path.isfile('../first.tbz2')
 
233
        self.runbzr('export ../first.tar.bz2 -r 1')
 
234
        assert os.path.isfile('../first.tar.bz2')
 
235
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
236
        assert os.path.isfile('../first.tar.tbz2')
 
237
        from bz2 import BZ2File
 
238
        tf = TarFile('../first.tar.tbz2', 
 
239
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
240
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
241
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
242
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
243
        tf = TarFile('../first2.tar')
 
244
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
245
 
 
246
    def test_diff(self):
 
247
        self.example_branch()
 
248
        file('hello', 'wt').write('hello world!')
 
249
        self.runbzr('commit -m fixing hello')
 
250
        output = self.runbzr('diff -r 2..3', backtick=1)
 
251
        self.assert_('\n+hello world!' in output)
 
252
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
253
        self.assert_('\n+baz' in output)
 
254
 
 
255
    def test_branch(self):
 
256
        """Branch from one branch to another."""
 
257
        os.mkdir('a')
 
258
        os.chdir('a')
 
259
        self.example_branch()
 
260
        os.chdir('..')
 
261
        self.runbzr('branch a b')
 
262
        self.runbzr('branch a c -r 1')
 
263
        os.chdir('b')
 
264
        self.runbzr('commit -m foo --unchanged')
 
265
        os.chdir('..')
 
266
        # naughty - abstraction violations RBC 20050928  
 
267
        print "test_branch used to delete the stores, how is this meant to work ?"
 
268
        #shutil.rmtree('a/.bzr/revision-store')
 
269
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
270
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
271
        self.runbzr('branch a d --basis b')
 
272
 
 
273
    def test_merge(self):
 
274
        from bzrlib.branch import Branch
 
275
        
 
276
        os.mkdir('a')
 
277
        os.chdir('a')
 
278
        self.example_branch()
 
279
        os.chdir('..')
 
280
        self.runbzr('branch a b')
 
281
        os.chdir('b')
 
282
        file('goodbye', 'wt').write('quux')
 
283
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
284
 
 
285
        os.chdir('../a')
 
286
        file('hello', 'wt').write('quuux')
 
287
        # We can't merge when there are in-tree changes
 
288
        self.runbzr('merge ../b', retcode=1)
 
289
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
290
        self.runbzr('merge ../b')
 
291
        self.check_file_contents('goodbye', 'quux')
 
292
        # Merging a branch pulls its revision into the tree
 
293
        a = Branch.open('.')
 
294
        b = Branch.open('../b')
 
295
        a.get_revision_xml(b.last_revision())
 
296
        self.log('pending merges: %s', a.pending_merges())
 
297
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
298
        #        % (a.pending_merges(), b.last_patch())
 
299
 
 
300
    def test_merge_with_missing_file(self):
 
301
        """Merge handles missing file conflicts"""
 
302
        os.mkdir('a')
 
303
        os.chdir('a')
 
304
        os.mkdir('sub')
 
305
        print >> file('sub/a.txt', 'wb'), "hello"
 
306
        print >> file('b.txt', 'wb'), "hello"
 
307
        print >> file('sub/c.txt', 'wb'), "hello"
 
308
        self.runbzr('init')
 
309
        self.runbzr('add')
 
310
        self.runbzr(('commit', '-m', 'added a'))
 
311
        self.runbzr('branch . ../b')
 
312
        print >> file('sub/a.txt', 'ab'), "there"
 
313
        print >> file('b.txt', 'ab'), "there"
 
314
        print >> file('sub/c.txt', 'ab'), "there"
 
315
        self.runbzr(('commit', '-m', 'Added there'))
 
316
        os.unlink('sub/a.txt')
 
317
        os.unlink('sub/c.txt')
 
318
        os.rmdir('sub')
 
319
        os.unlink('b.txt')
 
320
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
321
        os.chdir('../b')
 
322
        print >> file('sub/a.txt', 'ab'), "something"
 
323
        print >> file('b.txt', 'ab'), "something"
 
324
        print >> file('sub/c.txt', 'ab'), "something"
 
325
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
326
        self.runbzr('merge ../a/')
 
327
        assert os.path.exists('sub/a.txt.THIS')
 
328
        assert os.path.exists('sub/a.txt.BASE')
 
329
        os.chdir('../a')
 
330
        self.runbzr('merge ../b/')
 
331
        assert os.path.exists('sub/a.txt.OTHER')
 
332
        assert os.path.exists('sub/a.txt.BASE')
 
333
 
 
334
    def test_merge_with_missing_file(self):
 
335
        """Merge handles missing file conflicts"""
 
336
        os.mkdir('a')
 
337
        os.chdir('a')
 
338
        os.mkdir('sub')
 
339
        print >> file('sub/a.txt', 'wb'), "hello"
 
340
        print >> file('b.txt', 'wb'), "hello"
 
341
        print >> file('sub/c.txt', 'wb'), "hello"
 
342
        self.runbzr('init')
 
343
        self.runbzr('add')
 
344
        self.runbzr(('commit', '-m', 'added a'))
 
345
        self.runbzr('branch . ../b')
 
346
        print >> file('sub/a.txt', 'ab'), "there"
 
347
        print >> file('b.txt', 'ab'), "there"
 
348
        print >> file('sub/c.txt', 'ab'), "there"
 
349
        self.runbzr(('commit', '-m', 'Added there'))
 
350
        os.unlink('sub/a.txt')
 
351
        os.unlink('sub/c.txt')
 
352
        os.rmdir('sub')
 
353
        os.unlink('b.txt')
 
354
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
355
        os.chdir('../b')
 
356
        print >> file('sub/a.txt', 'ab'), "something"
 
357
        print >> file('b.txt', 'ab'), "something"
 
358
        print >> file('sub/c.txt', 'ab'), "something"
 
359
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
360
        self.runbzr('merge ../a/')
 
361
        assert os.path.exists('sub/a.txt.THIS')
 
362
        assert os.path.exists('sub/a.txt.BASE')
 
363
        os.chdir('../a')
 
364
        self.runbzr('merge ../b/')
 
365
        assert os.path.exists('sub/a.txt.OTHER')
 
366
        assert os.path.exists('sub/a.txt.BASE')
 
367
 
 
368
    def test_pull(self):
 
369
        """Pull changes from one branch to another."""
 
370
        os.mkdir('a')
 
371
        os.chdir('a')
 
372
 
 
373
        self.example_branch()
 
374
        self.runbzr('pull', retcode=1)
 
375
        self.runbzr('missing', retcode=1)
 
376
        self.runbzr('missing .')
 
377
        self.runbzr('missing')
 
378
        self.runbzr('pull')
 
379
        self.runbzr('pull /', retcode=1)
 
380
        self.runbzr('pull')
 
381
 
 
382
        os.chdir('..')
 
383
        self.runbzr('branch a b')
 
384
        os.chdir('b')
 
385
        self.runbzr('pull')
 
386
        os.mkdir('subdir')
 
387
        self.runbzr('add subdir')
 
388
        self.runbzr('commit -m blah --unchanged')
 
389
        os.chdir('../a')
 
390
        a = Branch.open('.')
 
391
        b = Branch.open('../b')
 
392
        assert a.revision_history() == b.revision_history()[:-1]
 
393
        self.runbzr('pull ../b')
 
394
        assert a.revision_history() == b.revision_history()
 
395
        self.runbzr('commit -m blah2 --unchanged')
 
396
        os.chdir('../b')
 
397
        self.runbzr('commit -m blah3 --unchanged')
 
398
        self.runbzr('pull ../a', retcode=1)
 
399
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
400
        return
 
401
        os.chdir('../a')
 
402
        self.runbzr('merge ../b')
 
403
        self.runbzr('commit -m blah4 --unchanged')
 
404
        os.chdir('../b/subdir')
 
405
        self.runbzr('pull ../../a')
 
406
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
407
        self.runbzr('commit -m blah5 --unchanged')
 
408
        self.runbzr('commit -m blah6 --unchanged')
 
409
        os.chdir('..')
 
410
        self.runbzr('pull ../a')
 
411
        os.chdir('../a')
 
412
        self.runbzr('commit -m blah7 --unchanged')
 
413
        self.runbzr('merge ../b')
 
414
        self.runbzr('commit -m blah8 --unchanged')
 
415
        self.runbzr('pull ../b')
 
416
        self.runbzr('pull ../b')
 
417
        
 
418
    def test_add_reports(self):
 
419
        """add command prints the names of added files."""
 
420
        b = Branch.initialize('.')
 
421
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
422
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
423
        # the ordering is not defined at the moment
 
424
        results = sorted(out.rstrip('\n').split('\n'))
 
425
        self.assertEquals(['added dir',
 
426
                           'added dir'+os.sep+'sub.txt',
 
427
                           'added top.txt',],
 
428
                          results)
 
429
 
 
430
    def test_unknown_command(self):
 
431
        """Handling of unknown command."""
 
432
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
433
                                         retcode=1)
 
434
        self.assertEquals(out, '')
 
435
        err.index('unknown command')
 
436
        
 
437
 
 
438
 
 
439
class OldTests(ExternalBase):
 
440
    """old tests moved from ./testbzr."""
 
441
 
 
442
    def test_bzr(self):
 
443
        from os import chdir, mkdir
 
444
        from os.path import exists
 
445
 
 
446
        runbzr = self.runbzr
 
447
        capture = self.capture
 
448
        progress = self.log
 
449
 
 
450
        progress("basic branch creation")
 
451
        mkdir('branch1')
 
452
        chdir('branch1')
 
453
        runbzr('init')
 
454
 
 
455
        self.assertEquals(capture('root').rstrip(),
 
456
                          os.path.join(self.test_dir, 'branch1'))
 
457
 
 
458
        progress("status of new file")
 
459
 
 
460
        f = file('test.txt', 'wt')
 
461
        f.write('hello world!\n')
 
462
        f.close()
 
463
 
 
464
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
465
 
 
466
        out = capture("status")
 
467
        assert out == 'unknown:\n  test.txt\n'
 
468
 
 
469
        out = capture("status --all")
 
470
        assert out == "unknown:\n  test.txt\n"
 
471
 
 
472
        out = capture("status test.txt --all")
 
473
        assert out == "unknown:\n  test.txt\n"
 
474
 
 
475
        f = file('test2.txt', 'wt')
 
476
        f.write('goodbye cruel world...\n')
 
477
        f.close()
 
478
 
 
479
        out = capture("status test.txt")
 
480
        assert out == "unknown:\n  test.txt\n"
 
481
 
 
482
        out = capture("status")
 
483
        assert out == ("unknown:\n"
 
484
                       "  test.txt\n"
 
485
                       "  test2.txt\n")
 
486
 
 
487
        os.unlink('test2.txt')
 
488
 
 
489
        progress("command aliases")
 
490
        out = capture("st --all")
 
491
        assert out == ("unknown:\n"
 
492
                       "  test.txt\n")
 
493
 
 
494
        out = capture("stat")
 
495
        assert out == ("unknown:\n"
 
496
                       "  test.txt\n")
 
497
 
 
498
        progress("command help")
 
499
        runbzr("help st")
 
500
        runbzr("help")
 
501
        runbzr("help commands")
 
502
        runbzr("help slartibartfast", 1)
 
503
 
 
504
        out = capture("help ci")
 
505
        out.index('aliases: ')
 
506
 
 
507
        progress("can't rename unversioned file")
 
508
        runbzr("rename test.txt new-test.txt", 1)
 
509
 
 
510
        progress("adding a file")
 
511
 
 
512
        runbzr("add test.txt")
 
513
        assert capture("unknowns") == ''
 
514
        assert capture("status --all") == ("added:\n"
 
515
                                                "  test.txt\n")
 
516
 
 
517
        progress("rename newly-added file")
 
518
        runbzr("rename test.txt hello.txt")
 
519
        assert os.path.exists("hello.txt")
 
520
        assert not os.path.exists("test.txt")
 
521
 
 
522
        assert capture("revno") == '0\n'
 
523
 
 
524
        progress("add first revision")
 
525
        runbzr(['commit', '-m', 'add first revision'])
 
526
 
 
527
        progress("more complex renames")
 
528
        os.mkdir("sub1")
 
529
        runbzr("rename hello.txt sub1", 1)
 
530
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
531
        runbzr("move hello.txt sub1", 1)
 
532
 
 
533
        runbzr("add sub1")
 
534
        runbzr("rename sub1 sub2")
 
535
        runbzr("move hello.txt sub2")
 
536
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
537
 
 
538
        assert exists("sub2")
 
539
        assert exists("sub2/hello.txt")
 
540
        assert not exists("sub1")
 
541
        assert not exists("hello.txt")
 
542
 
 
543
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
 
544
 
 
545
        mkdir("sub1")
 
546
        runbzr('add sub1')
 
547
        runbzr('move sub2/hello.txt sub1')
 
548
        assert not exists('sub2/hello.txt')
 
549
        assert exists('sub1/hello.txt')
 
550
        runbzr('move sub2 sub1')
 
551
        assert not exists('sub2')
 
552
        assert exists('sub1/sub2')
 
553
 
 
554
        runbzr(['commit', '-m', 'rename nested subdirectories'])
 
555
 
 
556
        chdir('sub1/sub2')
 
557
        self.assertEquals(capture('root')[:-1],
 
558
                          os.path.join(self.test_dir, 'branch1'))
 
559
        runbzr('move ../hello.txt .')
 
560
        assert exists('./hello.txt')
 
561
        self.assertEquals(capture('relpath hello.txt'),
 
562
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
563
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
564
        runbzr(['commit', '-m', 'move to parent directory'])
 
565
        chdir('..')
 
566
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
567
 
 
568
        runbzr('move sub2/hello.txt .')
 
569
        assert exists('hello.txt')
 
570
 
 
571
        f = file('hello.txt', 'wt')
 
572
        f.write('some nice new content\n')
 
573
        f.close()
 
574
 
 
575
        f = file('msg.tmp', 'wt')
 
576
        f.write('this is my new commit\n')
 
577
        f.close()
 
578
 
 
579
        runbzr('commit -F msg.tmp')
 
580
 
 
581
        assert capture('revno') == '5\n'
 
582
        runbzr('export -r 5 export-5.tmp')
 
583
        runbzr('export export.tmp')
 
584
 
 
585
        runbzr('log')
 
586
        runbzr('log -v')
 
587
        runbzr('log -v --forward')
 
588
        runbzr('log -m', retcode=1)
 
589
        log_out = capture('log -m commit')
 
590
        assert "this is my new commit" in log_out
 
591
        assert "rename nested" not in log_out
 
592
        assert 'revision-id' not in log_out
 
593
        assert 'revision-id' in capture('log --show-ids -m commit')
 
594
 
 
595
 
 
596
        progress("file with spaces in name")
 
597
        mkdir('sub directory')
 
598
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
 
599
        runbzr('add .')
 
600
        runbzr('diff')
 
601
        runbzr('commit -m add-spaces')
 
602
        runbzr('check')
 
603
 
 
604
        runbzr('log')
 
605
        runbzr('log --forward')
 
606
 
 
607
        runbzr('info')
 
608