/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-07 06:13:14 UTC
  • mto: This revision was merged to the branch mainline in revision 1420.
  • Revision ID: robertc@robertcollins.net-20051007061313-9a835e979434e721
use transactions in the weave store interface, which enables caching for log

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_patch())
 
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_merge_with_missing_file(self):
 
348
        """Merge handles missing file conflicts"""
 
349
        os.mkdir('a')
 
350
        os.chdir('a')
 
351
        os.mkdir('sub')
 
352
        print >> file('sub/a.txt', 'wb'), "hello"
 
353
        print >> file('b.txt', 'wb'), "hello"
 
354
        print >> file('sub/c.txt', 'wb'), "hello"
 
355
        self.runbzr('init')
 
356
        self.runbzr('add')
 
357
        self.runbzr(('commit', '-m', 'added a'))
 
358
        self.runbzr('branch . ../b')
 
359
        print >> file('sub/a.txt', 'ab'), "there"
 
360
        print >> file('b.txt', 'ab'), "there"
 
361
        print >> file('sub/c.txt', 'ab'), "there"
 
362
        self.runbzr(('commit', '-m', 'Added there'))
 
363
        os.unlink('sub/a.txt')
 
364
        os.unlink('sub/c.txt')
 
365
        os.rmdir('sub')
 
366
        os.unlink('b.txt')
 
367
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
368
        os.chdir('../b')
 
369
        print >> file('sub/a.txt', 'ab'), "something"
 
370
        print >> file('b.txt', 'ab'), "something"
 
371
        print >> file('sub/c.txt', 'ab'), "something"
 
372
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
373
        self.runbzr('merge ../a/')
 
374
        assert os.path.exists('sub/a.txt.THIS')
 
375
        assert os.path.exists('sub/a.txt.BASE')
 
376
        os.chdir('../a')
 
377
        self.runbzr('merge ../b/')
 
378
        assert os.path.exists('sub/a.txt.OTHER')
 
379
        assert os.path.exists('sub/a.txt.BASE')
 
380
 
 
381
    def test_pull(self):
 
382
        """Pull changes from one branch to another."""
 
383
        os.mkdir('a')
 
384
        os.chdir('a')
 
385
 
 
386
        self.example_branch()
 
387
        self.runbzr('pull', retcode=1)
 
388
        self.runbzr('missing', retcode=1)
 
389
        self.runbzr('missing .')
 
390
        self.runbzr('missing')
 
391
        self.runbzr('pull')
 
392
        self.runbzr('pull /', retcode=1)
 
393
        self.runbzr('pull')
 
394
 
 
395
        os.chdir('..')
 
396
        self.runbzr('branch a b')
 
397
        os.chdir('b')
 
398
        self.runbzr('pull')
 
399
        os.mkdir('subdir')
 
400
        self.runbzr('add subdir')
 
401
        self.runbzr('commit -m blah --unchanged')
 
402
        os.chdir('../a')
 
403
        a = Branch.open('.')
 
404
        b = Branch.open('../b')
 
405
        assert a.revision_history() == b.revision_history()[:-1]
 
406
        self.runbzr('pull ../b')
 
407
        assert a.revision_history() == b.revision_history()
 
408
        self.runbzr('commit -m blah2 --unchanged')
 
409
        os.chdir('../b')
 
410
        self.runbzr('commit -m blah3 --unchanged')
 
411
        self.runbzr('pull ../a', retcode=1)
 
412
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
413
        return
 
414
        os.chdir('../a')
 
415
        self.runbzr('merge ../b')
 
416
        self.runbzr('commit -m blah4 --unchanged')
 
417
        os.chdir('../b/subdir')
 
418
        self.runbzr('pull ../../a')
 
419
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
420
        self.runbzr('commit -m blah5 --unchanged')
 
421
        self.runbzr('commit -m blah6 --unchanged')
 
422
        os.chdir('..')
 
423
        self.runbzr('pull ../a')
 
424
        os.chdir('../a')
 
425
        self.runbzr('commit -m blah7 --unchanged')
 
426
        self.runbzr('merge ../b')
 
427
        self.runbzr('commit -m blah8 --unchanged')
 
428
        self.runbzr('pull ../b')
 
429
        self.runbzr('pull ../b')
 
430
 
 
431
    def test_locations(self):
 
432
        """Using and remembering different locations"""
 
433
        os.mkdir('a')
 
434
        os.chdir('a')
 
435
        self.runbzr('init')
 
436
        self.runbzr('commit -m unchanged --unchanged')
 
437
        self.runbzr('pull', retcode=1)
 
438
        self.runbzr('merge', retcode=1)
 
439
        self.runbzr('branch . ../b')
 
440
        os.chdir('../b')
 
441
        self.runbzr('pull')
 
442
        self.runbzr('branch . ../c')
 
443
        self.runbzr('pull ../c')
 
444
        self.runbzr('merge')
 
445
        os.chdir('../a')
 
446
        self.runbzr('pull ../b')
 
447
        self.runbzr('pull')
 
448
        self.runbzr('pull ../c')
 
449
        self.runbzr('branch ../c ../d')
 
450
        shutil.rmtree('../c')
 
451
        self.runbzr('pull')
 
452
        os.chdir('../b')
 
453
        self.runbzr('pull')
 
454
        os.chdir('../d')
 
455
        self.runbzr('pull', retcode=1)
 
456
        self.runbzr('pull ../a --remember')
 
457
        self.runbzr('pull')
 
458
        
 
459
    def test_add_reports(self):
 
460
        """add command prints the names of added files."""
 
461
        b = Branch.initialize('.')
 
462
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
463
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
464
        # the ordering is not defined at the moment
 
465
        results = sorted(out.rstrip('\n').split('\n'))
 
466
        self.assertEquals(['added dir',
 
467
                           'added dir'+os.sep+'sub.txt',
 
468
                           'added top.txt',],
 
469
                          results)
 
470
 
 
471
    def test_unknown_command(self):
 
472
        """Handling of unknown command."""
 
473
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
474
                                         retcode=1)
 
475
        self.assertEquals(out, '')
 
476
        err.index('unknown command')
 
477
 
 
478
    def test_conflicts(self):
 
479
        """Handling of merge conflicts"""
 
480
        os.mkdir('base')
 
481
        os.chdir('base')
 
482
        file('hello', 'wb').write("hi world")
 
483
        file('answer', 'wb').write("42")
 
484
        self.runbzr('init')
 
485
        self.runbzr('add')
 
486
        self.runbzr('commit -m base')
 
487
        self.runbzr('branch . ../other')
 
488
        self.runbzr('branch . ../this')
 
489
        os.chdir('../other')
 
490
        file('hello', 'wb').write("Hello.")
 
491
        file('answer', 'wb').write("Is anyone there?")
 
492
        self.runbzr('commit -m other')
 
493
        os.chdir('../this')
 
494
        file('hello', 'wb').write("Hello, world")
 
495
        self.runbzr('mv answer question')
 
496
        file('question', 'wb').write("What do you get when you multiply six"
 
497
                                   "times nine?")
 
498
        self.runbzr('commit -m this')
 
499
        self.runbzr('merge ../other')
 
500
        result = self.runbzr('conflicts', backtick=1)
 
501
        self.assertEquals(result, "hello\nquestion\n")
 
502
        result = self.runbzr('status', backtick=1)
 
503
        assert "conflicts:\n  hello\n  question\n" in result, result
 
504
        self.runbzr('resolve hello')
 
505
        result = self.runbzr('conflicts', backtick=1)
 
506
        self.assertEquals(result, "question\n")
 
507
        self.runbzr('commit -m conflicts', retcode=1)
 
508
        self.runbzr('resolve --all')
 
509
        result = self.runbzr('conflicts', backtick=1)
 
510
        self.runbzr('commit -m conflicts')
 
511
        self.assertEquals(result, "")
 
512
 
 
513
def listdir_sorted(dir):
 
514
    L = os.listdir(dir)
 
515
    L.sort()
 
516
    return L
180
517
 
181
518
 
182
519
class OldTests(ExternalBase):
183
 
    # old tests moved from ./testbzr
184
 
    def runTest(self):
 
520
    """old tests moved from ./testbzr."""
 
521
 
 
522
    def test_bzr(self):
185
523
        from os import chdir, mkdir
186
524
        from os.path import exists
187
 
        import os
188
525
 
189
526
        runbzr = self.runbzr
190
 
        backtick = self.backtick
 
527
        capture = self.capture
191
528
        progress = self.log
192
529
 
193
530
        progress("basic branch creation")
195
532
        chdir('branch1')
196
533
        runbzr('init')
197
534
 
198
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
535
        self.assertEquals(capture('root').rstrip(),
199
536
                          os.path.join(self.test_dir, 'branch1'))
200
537
 
201
538
        progress("status of new file")
204
541
        f.write('hello world!\n')
205
542
        f.close()
206
543
 
207
 
        out = backtick("bzr unknowns")
208
 
        self.assertEquals(out, 'test.txt\n')
 
544
        self.assertEquals(capture('unknowns'), 'test.txt\n')
209
545
 
210
 
        out = backtick("bzr status")
 
546
        out = capture("status")
211
547
        assert out == 'unknown:\n  test.txt\n'
212
548
 
213
 
        out = backtick("bzr status --all")
 
549
        out = capture("status --all")
214
550
        assert out == "unknown:\n  test.txt\n"
215
551
 
216
 
        out = backtick("bzr status test.txt --all")
 
552
        out = capture("status test.txt --all")
217
553
        assert out == "unknown:\n  test.txt\n"
218
554
 
219
555
        f = file('test2.txt', 'wt')
220
556
        f.write('goodbye cruel world...\n')
221
557
        f.close()
222
558
 
223
 
        out = backtick("bzr status test.txt")
 
559
        out = capture("status test.txt")
224
560
        assert out == "unknown:\n  test.txt\n"
225
561
 
226
 
        out = backtick("bzr status")
 
562
        out = capture("status")
227
563
        assert out == ("unknown:\n"
228
564
                       "  test.txt\n"
229
565
                       "  test2.txt\n")
231
567
        os.unlink('test2.txt')
232
568
 
233
569
        progress("command aliases")
234
 
        out = backtick("bzr st --all")
 
570
        out = capture("st --all")
235
571
        assert out == ("unknown:\n"
236
572
                       "  test.txt\n")
237
573
 
238
 
        out = backtick("bzr stat")
 
574
        out = capture("stat")
239
575
        assert out == ("unknown:\n"
240
576
                       "  test.txt\n")
241
577
 
245
581
        runbzr("help commands")
246
582
        runbzr("help slartibartfast", 1)
247
583
 
248
 
        out = backtick("bzr help ci")
 
584
        out = capture("help ci")
249
585
        out.index('aliases: ')
250
586
 
251
587
        progress("can't rename unversioned file")
254
590
        progress("adding a file")
255
591
 
256
592
        runbzr("add test.txt")
257
 
        assert backtick("bzr unknowns") == ''
258
 
        assert backtick("bzr status --all") == ("added:\n"
 
593
        assert capture("unknowns") == ''
 
594
        assert capture("status --all") == ("added:\n"
259
595
                                                "  test.txt\n")
260
596
 
261
597
        progress("rename newly-added file")
263
599
        assert os.path.exists("hello.txt")
264
600
        assert not os.path.exists("test.txt")
265
601
 
266
 
        assert backtick("bzr revno") == '0\n'
 
602
        assert capture("revno") == '0\n'
267
603
 
268
604
        progress("add first revision")
269
605
        runbzr(['commit', '-m', 'add first revision'])
277
613
        runbzr("add sub1")
278
614
        runbzr("rename sub1 sub2")
279
615
        runbzr("move hello.txt sub2")
280
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
616
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
281
617
 
282
618
        assert exists("sub2")
283
619
        assert exists("sub2/hello.txt")
298
634
        runbzr(['commit', '-m', 'rename nested subdirectories'])
299
635
 
300
636
        chdir('sub1/sub2')
301
 
        self.assertEquals(backtick('bzr root')[:-1],
 
637
        self.assertEquals(capture('root')[:-1],
302
638
                          os.path.join(self.test_dir, 'branch1'))
303
639
        runbzr('move ../hello.txt .')
304
640
        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')
 
641
        self.assertEquals(capture('relpath hello.txt'),
 
642
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
643
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
307
644
        runbzr(['commit', '-m', 'move to parent directory'])
308
645
        chdir('..')
309
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
646
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
310
647
 
311
648
        runbzr('move sub2/hello.txt .')
312
649
        assert exists('hello.txt')
321
658
 
322
659
        runbzr('commit -F msg.tmp')
323
660
 
324
 
        assert backtick('bzr revno') == '5\n'
 
661
        assert capture('revno') == '5\n'
325
662
        runbzr('export -r 5 export-5.tmp')
326
663
        runbzr('export export.tmp')
327
664
 
329
666
        runbzr('log -v')
330
667
        runbzr('log -v --forward')
331
668
        runbzr('log -m', retcode=1)
332
 
        log_out = backtick('bzr log -m commit')
 
669
        log_out = capture('log -m commit')
333
670
        assert "this is my new commit" in log_out
334
671
        assert "rename nested" not in log_out
335
672
        assert 'revision-id' not in log_out
336
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
673
        assert 'revision-id' in capture('log --show-ids -m commit')
337
674
 
338
675
 
339
676
        progress("file with spaces in name")
349
686
 
350
687
        runbzr('info')
351
688
 
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
 
 
 
689
        if has_symlinks():
 
690
            progress("symlinks")
 
691
            mkdir('symlinks')
 
692
            chdir('symlinks')
 
693
            runbzr('init')
 
694
            os.symlink("NOWHERE1", "link1")
 
695
            runbzr('add link1')
 
696
            assert self.capture('unknowns') == ''
 
697
            runbzr(['commit', '-m', '1: added symlink link1'])
 
698
    
 
699
            mkdir('d1')
 
700
            runbzr('add d1')
 
701
            assert self.capture('unknowns') == ''
 
702
            os.symlink("NOWHERE2", "d1/link2")
 
703
            assert self.capture('unknowns') == 'd1/link2\n'
 
704
            # is d1/link2 found when adding d1
 
705
            runbzr('add d1')
 
706
            assert self.capture('unknowns') == ''
 
707
            os.symlink("NOWHERE3", "d1/link3")
 
708
            assert self.capture('unknowns') == 'd1/link3\n'
 
709
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
710
    
 
711
            runbzr('rename d1 d2')
 
712
            runbzr('move d2/link2 .')
 
713
            runbzr('move link1 d2')
 
714
            assert os.readlink("./link2") == "NOWHERE2"
 
715
            assert os.readlink("d2/link1") == "NOWHERE1"
 
716
            runbzr('add d2/link3')
 
717
            runbzr('diff')
 
718
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
719
    
 
720
            os.unlink("link2")
 
721
            os.symlink("TARGET 2", "link2")
 
722
            os.unlink("d2/link1")
 
723
            os.symlink("TARGET 1", "d2/link1")
 
724
            runbzr('diff')
 
725
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
726
            runbzr(['commit', '-m', '4: retarget of two links'])
 
727
    
 
728
            runbzr('remove d2/link1')
 
729
            assert self.capture('unknowns') == 'd2/link1\n'
 
730
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
731
    
 
732
            os.mkdir("d1")
 
733
            runbzr('add d1')
 
734
            runbzr('rename d2/link3 d1/link3new')
 
735
            assert self.capture('unknowns') == 'd2/link1\n'
 
736
            runbzr(['commit', '-m', '6: remove d2/link1, move/rename link3'])
 
737
            
 
738
            runbzr(['check'])
 
739
            
 
740
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
741
            chdir("exp1.tmp")
 
742
            assert listdir_sorted(".") == [ "link1" ]
 
743
            assert os.readlink("link1") == "NOWHERE1"
 
744
            chdir("..")
 
745
            
 
746
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
747
            chdir("exp2.tmp")
 
748
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
749
            chdir("..")
 
750
            
 
751
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
752
            chdir("exp3.tmp")
 
753
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
754
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
755
            assert os.readlink("d2/link1") == "NOWHERE1"
 
756
            assert os.readlink("link2")    == "NOWHERE2"
 
757
            chdir("..")
 
758
            
 
759
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
760
            chdir("exp4.tmp")
 
761
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
762
            assert os.readlink("d2/link1") == "TARGET 1"
 
763
            assert os.readlink("link2")    == "TARGET 2"
 
764
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
765
            chdir("..")
 
766
            
 
767
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
768
            chdir("exp5.tmp")
 
769
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
770
            assert os.path.islink("link2")
 
771
            assert listdir_sorted("d2")== [ "link3" ]
 
772
            chdir("..")
 
773
            
 
774
            runbzr(['export', '-r', '6', 'exp6.tmp'])
 
775
            chdir("exp6.tmp")
 
776
            assert listdir_sorted(".") == [ "d1", "d2", "link2" ]
 
777
            assert listdir_sorted("d1") == [ "link3new" ]
 
778
            assert listdir_sorted("d2") == []
 
779
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
780
            chdir("..")
 
781
        else:
 
782
            progress("skipping symlink tests")
 
783
 
 
784
 
 
785
class HttpTests(TestCaseWithWebserver):
 
786
    """Test bzr ui commands against remote branches."""
 
787
 
 
788
    def test_branch(self):
 
789
        os.mkdir('from')
 
790
        branch = Branch.initialize('from')
 
791
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
792
        url = self.get_remote_url('from')
 
793
        self.run_bzr('branch', url, 'to')
 
794
        branch = Branch.open('to')
 
795
        self.assertEqual(1, len(branch.revision_history()))