← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-08-18 05:44:39 UTC
  • Revision ID: mbp@sourcefrog.net-20050818054439-ba0873b87a8c1671
- add code to run weave utility under profiler

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
# Mr. Smoketoomuch: I'm sorry?
19
 
# Mr. Bounder: You'd better cut down a little then.
20
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
21
 
#                   then!
22
18
 
23
19
"""Black-box tests for bzr.
24
20
 
25
21
These check that it behaves properly when it's invoked through the regular
26
 
command-line interface. This doesn't actually run a new interpreter but 
27
 
rather starts again from the run_bzr function.
 
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.
28
27
"""
29
28
 
30
 
 
31
 
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
32
 
# Note: Please don't add new tests here, it's too big and bulky.  Instead add
33
 
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
34
 
# UI command/aspect that is being tested.
35
 
 
36
 
 
37
 
from cStringIO import StringIO
38
 
import os
39
 
import re
40
29
import sys
41
30
 
42
 
import bzrlib
43
 
from bzrlib.branch import Branch
44
 
import bzrlib.bzrdir as bzrdir
45
 
from bzrlib.errors import BzrCommandError
46
 
from bzrlib.osutils import (
47
 
    has_symlinks,
48
 
    pathjoin,
49
 
    rmtree,
50
 
    terminal_width,
51
 
    )
52
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
53
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
54
 
from bzrlib.tests.blackbox import ExternalBase
55
 
from bzrlib.workingtree import WorkingTree
56
 
 
57
 
 
58
 
class TestCommands(ExternalBase):
59
 
 
60
 
    def test_whoami(self):
 
31
from bzrlib.selftest import TestBase, InTempDir, BzrTestBase
 
32
 
 
33
 
 
34
 
 
35
class ExternalBase(InTempDir):
 
36
    def runbzr(self, args, retcode=0,backtick=False):
 
37
        try:
 
38
            import shutil
 
39
            from subprocess import call
 
40
        except ImportError, e:
 
41
            _need_subprocess()
 
42
            raise
 
43
 
 
44
        if isinstance(args, basestring):
 
45
            args = args.split()
 
46
 
 
47
        if backtick:
 
48
            return self.backtick(['python', self.BZRPATH,] + args,
 
49
                           retcode=retcode)
 
50
        else:
 
51
            return self.runcmd(['python', self.BZRPATH,] + args,
 
52
                           retcode=retcode)
 
53
 
 
54
 
 
55
 
 
56
class MvCommand(BzrTestBase):
 
57
    def runbzr(self):
 
58
        """Test two modes of operation for mv"""
 
59
        b = Branch('.', init=True)
 
60
        self.build_tree(['a', 'c', 'subdir/'])
 
61
        self.run_bzr('mv', 'a', 'b')
 
62
        self.run_bzr('mv', 'b', 'subdir')
 
63
        self.run_bzr('mv', 'subdir/b', 'a')
 
64
        self.run_bzr('mv', 'a', 'b', 'subdir')
 
65
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
66
 
 
67
 
 
68
 
 
69
class TestVersion(BzrTestBase):
 
70
    """Check output from version command and master option is reasonable"""
 
71
    def runTest(self):
 
72
        # output is intentionally passed through to stdout so that we
 
73
        # can see the version being tested
 
74
        from cStringIO import StringIO
 
75
        save_out = sys.stdout
 
76
        try:
 
77
            sys.stdout = tmp_out = StringIO()
 
78
            
 
79
            self.run_bzr('version')
 
80
        finally:
 
81
            sys.stdout = save_out
 
82
 
 
83
        output = tmp_out.getvalue()
 
84
        self.log('bzr version output:')
 
85
        self.log(output)
 
86
        
 
87
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
88
        self.assertNotEqual(output.index('Canonical'), -1)
 
89
 
 
90
        # make sure --version is consistent
 
91
        try:
 
92
            sys.stdout = tmp_out = StringIO()
 
93
            
 
94
            self.run_bzr('--version')
 
95
        finally:
 
96
            sys.stdout = save_out
 
97
 
 
98
        self.log('bzr --version output:')
 
99
        self.log(tmp_out.getvalue())
 
100
 
 
101
        self.assertEquals(output, tmp_out.getvalue())
 
102
 
 
103
 
 
104
        
 
105
 
 
106
 
 
107
class HelpCommands(ExternalBase):
 
108
    def runTest(self):
 
109
        self.runbzr('--help')
 
110
        self.runbzr('help')
 
111
        self.runbzr('help commands')
 
112
        self.runbzr('help help')
 
113
        self.runbzr('commit -h')
 
114
 
 
115
 
 
116
class InitBranch(ExternalBase):
 
117
    def runTest(self):
 
118
        import os
 
119
        self.runbzr(['init'])
 
120
 
 
121
 
 
122
 
 
123
class UserIdentity(ExternalBase):
 
124
    def runTest(self):
61
125
        # this should always identify something, if only "john@localhost"
62
126
        self.runbzr("whoami")
63
127
        self.runbzr("whoami --email")
65
129
        self.assertEquals(self.runbzr("whoami --email",
66
130
                                      backtick=True).count('@'), 1)
67
131
        
68
 
    def test_whoami_branch(self):
69
 
        """branch specific user identity works."""
 
132
class UserIdentityBranch(ExternalBase):
 
133
    def runTest(self):
 
134
        # tests branch specific user identity
70
135
        self.runbzr('init')
71
 
        b = bzrlib.branch.Branch.open('.')
72
 
        b.control_files.put_utf8('email', 'Branch Identity <branch@identi.ty>')
73
 
        bzr_email = os.environ.get('BZREMAIL')
74
 
        if bzr_email is not None:
75
 
            del os.environ['BZREMAIL']
 
136
        f = file('.bzr/email', 'wt')
 
137
        f.write('Branch Identity <branch@identi.ty>')
 
138
        f.close()
76
139
        whoami = self.runbzr("whoami",backtick=True)
77
140
        whoami_email = self.runbzr("whoami --email",backtick=True)
78
141
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
79
142
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
80
 
        # Verify that the environment variable overrides the value 
81
 
        # in the file
82
 
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
83
 
        whoami = self.runbzr("whoami",backtick=True)
84
 
        whoami_email = self.runbzr("whoami --email",backtick=True)
85
 
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
86
 
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
87
 
        if bzr_email is not None:
88
 
            os.environ['BZREMAIL'] = bzr_email
89
 
 
90
 
    def test_nick_command(self):
91
 
        """bzr nick for viewing, setting nicknames"""
92
 
        os.mkdir('me.dev')
93
 
        os.chdir('me.dev')
94
 
        self.runbzr('init')
95
 
        nick = self.runbzr("nick",backtick=True)
96
 
        self.assertEqual(nick, 'me.dev\n')
97
 
        nick = self.runbzr("nick moo")
98
 
        nick = self.runbzr("nick",backtick=True)
99
 
        self.assertEqual(nick, 'moo\n')
100
 
 
101
 
    def test_invalid_commands(self):
102
 
        self.runbzr("pants", retcode=3)
103
 
        self.runbzr("--pants off", retcode=3)
104
 
        self.runbzr("diff --message foo", retcode=3)
105
 
 
106
 
    def test_remove_deleted(self):
 
143
 
 
144
 
 
145
class InvalidCommands(ExternalBase):
 
146
    def runTest(self):
 
147
        self.runbzr("pants", retcode=1)
 
148
        self.runbzr("--pants off", retcode=1)
 
149
        self.runbzr("diff --message foo", retcode=1)
 
150
 
 
151
 
 
152
 
 
153
class EmptyCommit(ExternalBase):
 
154
    def runTest(self):
107
155
        self.runbzr("init")
108
 
        self.build_tree(['a'])
109
 
        self.runbzr(['add', 'a'])
110
 
        self.runbzr(['commit', '-m', 'added a'])
111
 
        os.unlink('a')
112
 
        self.runbzr(['remove', 'a'])
113
 
 
114
 
    def test_ignore_patterns(self):
115
 
        self.runbzr('init')
116
 
        self.assertEquals(self.capture('unknowns'), '')
 
156
        self.build_tree(['hello.txt'])
 
157
        self.runbzr("commit -m empty", retcode=1)
 
158
        self.runbzr("add hello.txt")
 
159
        self.runbzr("commit -m added")
 
160
 
 
161
 
 
162
 
 
163
class IgnorePatterns(ExternalBase):
 
164
    def runTest(self):
 
165
        from bzrlib.branch import Branch
 
166
        
 
167
        b = Branch('.', init=True)
 
168
        self.assertEquals(list(b.unknowns()), [])
117
169
 
118
170
        file('foo.tmp', 'wt').write('tmp files are ignored')
119
 
        self.assertEquals(self.capture('unknowns'), '')
 
171
        self.assertEquals(list(b.unknowns()), [])
 
172
        assert self.backtick('bzr unknowns') == ''
120
173
 
121
174
        file('foo.c', 'wt').write('int main() {}')
122
 
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
 
175
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
176
        assert self.backtick('bzr unknowns') == 'foo.c\n'
123
177
 
124
178
        self.runbzr(['add', 'foo.c'])
125
 
        self.assertEquals(self.capture('unknowns'), '')
 
179
        assert self.backtick('bzr unknowns') == ''
126
180
 
127
181
        # 'ignore' works when creating the .bzignore file
128
182
        file('foo.blah', 'wt').write('blah')
129
 
        self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
 
183
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
130
184
        self.runbzr('ignore *.blah')
131
 
        self.assertEquals(self.capture('unknowns'), '')
132
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
 
185
        self.assertEquals(list(b.unknowns()), [])
 
186
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
133
187
 
134
188
        # 'ignore' works when then .bzrignore file already exists
135
189
        file('garh', 'wt').write('garh')
136
 
        self.assertEquals(self.capture('unknowns'), 'garh\n')
 
190
        self.assertEquals(list(b.unknowns()), ['garh'])
 
191
        assert self.backtick('bzr unknowns') == 'garh\n'
137
192
        self.runbzr('ignore garh')
138
 
        self.assertEquals(self.capture('unknowns'), '')
139
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
140
 
 
141
 
    def test_revert(self):
142
 
        self.runbzr('init')
143
 
 
144
 
        file('hello', 'wt').write('foo')
145
 
        self.runbzr('add hello')
146
 
        self.runbzr('commit -m setup hello')
147
 
 
148
 
        file('goodbye', 'wt').write('baz')
149
 
        self.runbzr('add goodbye')
150
 
        self.runbzr('commit -m setup goodbye')
151
 
 
152
 
        file('hello', 'wt').write('bar')
153
 
        file('goodbye', 'wt').write('qux')
154
 
        self.runbzr('revert hello')
155
 
        self.check_file_contents('hello', 'foo')
156
 
        self.check_file_contents('goodbye', 'qux')
157
 
        self.runbzr('revert')
158
 
        self.check_file_contents('goodbye', 'baz')
159
 
 
160
 
        os.mkdir('revertdir')
161
 
        self.runbzr('add revertdir')
162
 
        self.runbzr('commit -m f')
163
 
        os.rmdir('revertdir')
164
 
        self.runbzr('revert')
165
 
 
166
 
        if has_symlinks():
167
 
            os.symlink('/unlikely/to/exist', 'symlink')
168
 
            self.runbzr('add symlink')
169
 
            self.runbzr('commit -m f')
170
 
            os.unlink('symlink')
171
 
            self.runbzr('revert')
172
 
            self.failUnlessExists('symlink')
173
 
            os.unlink('symlink')
174
 
            os.symlink('a-different-path', 'symlink')
175
 
            self.runbzr('revert')
176
 
            self.assertEqual('/unlikely/to/exist',
177
 
                             os.readlink('symlink'))
178
 
        else:
179
 
            self.log("skipping revert symlink tests")
180
 
        
181
 
        file('hello', 'wt').write('xyz')
182
 
        self.runbzr('commit -m xyz hello')
183
 
        self.runbzr('revert -r 1 hello')
184
 
        self.check_file_contents('hello', 'foo')
185
 
        self.runbzr('revert hello')
186
 
        self.check_file_contents('hello', 'xyz')
187
 
        os.chdir('revertdir')
188
 
        self.runbzr('revert')
189
 
        os.chdir('..')
190
 
 
191
 
    def test_mv_modes(self):
192
 
        """Test two modes of operation for mv"""
193
 
        self.runbzr('init')
194
 
        self.build_tree(['a', 'c', 'subdir/'])
195
 
        self.run_bzr_captured(['add', self.test_dir])
196
 
        self.run_bzr_captured(['mv', 'a', 'b'])
197
 
        self.run_bzr_captured(['mv', 'b', 'subdir'])
198
 
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
199
 
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
200
 
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
201
 
 
202
 
    def test_main_version(self):
203
 
        """Check output from version command and master option is reasonable"""
204
 
        # output is intentionally passed through to stdout so that we
205
 
        # can see the version being tested
206
 
        output = self.runbzr('version', backtick=1)
207
 
        self.log('bzr version output:')
208
 
        self.log(output)
209
 
        self.assert_(output.startswith('bzr (bazaar-ng) '))
210
 
        self.assertNotEqual(output.index('Canonical'), -1)
211
 
        # make sure --version is consistent
212
 
        tmp_output = self.runbzr('--version', backtick=1)
213
 
        self.log('bzr --version output:')
214
 
        self.log(tmp_output)
215
 
        self.assertEquals(output, tmp_output)
216
 
 
217
 
    def example_branch(test):
218
 
        test.runbzr('init')
219
 
        file('hello', 'wt').write('foo')
220
 
        test.runbzr('add hello')
221
 
        test.runbzr('commit -m setup hello')
222
 
        file('goodbye', 'wt').write('baz')
223
 
        test.runbzr('add goodbye')
224
 
        test.runbzr('commit -m setup goodbye')
225
 
 
226
 
    def test_export(self):
227
 
        os.mkdir('branch')
228
 
        os.chdir('branch')
229
 
        self.example_branch()
230
 
        self.runbzr('export ../latest')
231
 
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
232
 
        self.runbzr('export ../first -r 1')
233
 
        self.assert_(not os.path.exists('../first/goodbye'))
234
 
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
235
 
        self.runbzr('export ../first.gz -r 1')
236
 
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
237
 
        self.runbzr('export ../first.bz2 -r 1')
238
 
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
239
 
 
240
 
        from tarfile import TarFile
241
 
        self.runbzr('export ../first.tar -r 1')
242
 
        self.assert_(os.path.isfile('../first.tar'))
243
 
        tf = TarFile('../first.tar')
244
 
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
245
 
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
246
 
        self.runbzr('export ../first.tar.gz -r 1')
247
 
        self.assert_(os.path.isfile('../first.tar.gz'))
248
 
        self.runbzr('export ../first.tbz2 -r 1')
249
 
        self.assert_(os.path.isfile('../first.tbz2'))
250
 
        self.runbzr('export ../first.tar.bz2 -r 1')
251
 
        self.assert_(os.path.isfile('../first.tar.bz2'))
252
 
        self.runbzr('export ../first.tar.tbz2 -r 1')
253
 
        self.assert_(os.path.isfile('../first.tar.tbz2'))
254
 
 
255
 
        from bz2 import BZ2File
256
 
        tf = TarFile('../first.tar.tbz2', 
257
 
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
258
 
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
259
 
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
260
 
        self.runbzr('export ../first2.tar -r 1 --root pizza')
261
 
        tf = TarFile('../first2.tar')
262
 
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
263
 
 
264
 
        from zipfile import ZipFile
265
 
        self.runbzr('export ../first.zip -r 1')
266
 
        self.failUnlessExists('../first.zip')
267
 
        zf = ZipFile('../first.zip')
268
 
        self.assert_('first/hello' in zf.namelist(), zf.namelist())
269
 
        self.assertEqual(zf.read('first/hello'), 'foo')
270
 
 
271
 
        self.runbzr('export ../first2.zip -r 1 --root pizza')
272
 
        zf = ZipFile('../first2.zip')
273
 
        self.assert_('pizza/hello' in zf.namelist(), zf.namelist())
274
 
        
275
 
        self.runbzr('export ../first-zip --format=zip -r 1')
276
 
        zf = ZipFile('../first-zip')
277
 
        self.assert_('first-zip/hello' in zf.namelist(), zf.namelist())
278
 
 
279
 
    def test_branch(self):
280
 
        """Branch from one branch to another."""
281
 
        os.mkdir('a')
282
 
        os.chdir('a')
283
 
        self.example_branch()
284
 
        os.chdir('..')
285
 
        self.runbzr('branch a b')
286
 
        b = bzrlib.branch.Branch.open('b')
287
 
        self.assertEqual('b\n', b.control_files.get_utf8('branch-name').read())
288
 
        self.runbzr('branch a c -r 1')
289
 
        os.chdir('b')
290
 
        self.runbzr('commit -m foo --unchanged')
291
 
        os.chdir('..')
292
 
 
293
 
    def test_branch_basis(self):
294
 
        # ensure that basis really does grab from the basis by having incomplete source
295
 
        tree = self.make_branch_and_tree('commit_tree')
296
 
        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))
297
 
        tree.add('foo')
298
 
        tree.commit('revision 1', rev_id='1')
299
 
        source = self.make_branch_and_tree('source')
300
 
        # this gives us an incomplete repository
301
 
        tree.bzrdir.open_repository().copy_content_into(source.branch.repository)
302
 
        tree.commit('revision 2', rev_id='2', allow_pointless=True)
303
 
        tree.bzrdir.open_branch().copy_content_into(source.branch)
304
 
        tree.copy_content_into(source)
305
 
        self.assertFalse(source.branch.repository.has_revision('2'))
306
 
        dir = source.bzrdir
307
 
        self.runbzr('branch source target --basis commit_tree')
308
 
        target = bzrdir.BzrDir.open('target')
309
 
        self.assertEqual('2', target.open_branch().last_revision())
310
 
        self.assertEqual('2', target.open_workingtree().last_revision())
311
 
        self.assertTrue(target.open_branch().repository.has_revision('2'))
312
 
 
313
 
    def test_inventory(self):
314
 
        bzr = self.runbzr
315
 
        def output_equals(value, *args):
316
 
            out = self.runbzr(['inventory'] + list(args), backtick=True)
317
 
            self.assertEquals(out, value)
318
 
 
319
 
        bzr('init')
320
 
        open('a', 'wb').write('hello\n')
321
 
        os.mkdir('b')
322
 
 
323
 
        bzr('add a b')
324
 
        bzr('commit -m add')
325
 
 
326
 
        output_equals('a\n', '--kind', 'file')
327
 
        output_equals('b\n', '--kind', 'directory')        
328
 
 
329
 
    def test_ls(self):
330
 
        """Test the abilities of 'bzr ls'"""
331
 
        bzr = self.runbzr
332
 
        def bzrout(*args, **kwargs):
333
 
            kwargs['backtick'] = True
334
 
            return self.runbzr(*args, **kwargs)
335
 
 
336
 
        def ls_equals(value, *args):
337
 
            out = self.runbzr(['ls'] + list(args), backtick=True)
338
 
            self.assertEquals(out, value)
339
 
 
340
 
        bzr('init')
341
 
        open('a', 'wb').write('hello\n')
342
 
 
343
 
        # Can't supply both
344
 
        bzr('ls --verbose --null', retcode=3)
345
 
 
346
 
        ls_equals('a\n')
347
 
        ls_equals('?        a\n', '--verbose')
348
 
        ls_equals('a\n', '--unknown')
349
 
        ls_equals('', '--ignored')
350
 
        ls_equals('', '--versioned')
351
 
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
352
 
        ls_equals('', '--ignored', '--versioned')
353
 
        ls_equals('a\0', '--null')
354
 
 
355
 
        bzr('add a')
356
 
        ls_equals('V        a\n', '--verbose')
357
 
        bzr('commit -m add')
358
 
        
359
 
        os.mkdir('subdir')
360
 
        ls_equals('V        a\n'
361
 
                  '?        subdir/\n'
362
 
                  , '--verbose')
363
 
        open('subdir/b', 'wb').write('b\n')
364
 
        bzr('add')
365
 
        ls_equals('V        a\n'
366
 
                  'V        subdir/\n'
367
 
                  'V        subdir/b\n'
368
 
                  , '--verbose')
369
 
        bzr('commit -m subdir')
370
 
 
371
 
        ls_equals('a\n'
372
 
                  'subdir\n'
373
 
                  , '--non-recursive')
374
 
 
375
 
        ls_equals('V        a\n'
376
 
                  'V        subdir/\n'
377
 
                  , '--verbose', '--non-recursive')
378
 
 
379
 
        # Check what happens in a sub-directory
380
 
        os.chdir('subdir')
381
 
        ls_equals('b\n')
382
 
        ls_equals('b\0'
383
 
                  , '--null')
384
 
        ls_equals('a\n'
385
 
                  'subdir\n'
386
 
                  'subdir/b\n'
387
 
                  , '--from-root')
388
 
        ls_equals('a\0'
389
 
                  'subdir\0'
390
 
                  'subdir/b\0'
391
 
                  , '--from-root', '--null')
392
 
        ls_equals('a\n'
393
 
                  'subdir\n'
394
 
                  , '--from-root', '--non-recursive')
395
 
 
396
 
        os.chdir('..')
397
 
 
398
 
        # Check what happens when we supply a specific revision
399
 
        ls_equals('a\n', '--revision', '1')
400
 
        ls_equals('V        a\n'
401
 
                  , '--verbose', '--revision', '1')
402
 
 
403
 
        os.chdir('subdir')
404
 
        ls_equals('', '--revision', '1')
405
 
 
406
 
        # Now try to do ignored files.
407
 
        os.chdir('..')
408
 
        open('blah.py', 'wb').write('unknown\n')
409
 
        open('blah.pyo', 'wb').write('ignored\n')
410
 
        ls_equals('a\n'
411
 
                  'blah.py\n'
412
 
                  'blah.pyo\n'
413
 
                  'subdir\n'
414
 
                  'subdir/b\n')
415
 
        ls_equals('V        a\n'
416
 
                  '?        blah.py\n'
417
 
                  'I        blah.pyo\n'
418
 
                  'V        subdir/\n'
419
 
                  'V        subdir/b\n'
420
 
                  , '--verbose')
421
 
        ls_equals('blah.pyo\n'
422
 
                  , '--ignored')
423
 
        ls_equals('blah.py\n'
424
 
                  , '--unknown')
425
 
        ls_equals('a\n'
426
 
                  'subdir\n'
427
 
                  'subdir/b\n'
428
 
                  , '--versioned')
429
 
 
430
 
    def test_cat(self):
431
 
        self.runbzr('init')
432
 
        file("myfile", "wb").write("My contents\n")
433
 
        self.runbzr('add')
434
 
        self.runbzr('commit -m myfile')
435
 
        self.run_bzr_captured('cat -r 1 myfile'.split(' '))
436
 
 
437
 
    def test_pull_verbose(self):
438
 
        """Pull changes from one branch to another and watch the output."""
439
 
 
440
 
        os.mkdir('a')
441
 
        os.chdir('a')
442
 
 
443
 
        bzr = self.runbzr
444
 
        self.example_branch()
445
 
 
446
 
        os.chdir('..')
447
 
        bzr('branch a b')
448
 
        os.chdir('b')
449
 
        open('b', 'wb').write('else\n')
450
 
        bzr('add b')
451
 
        bzr(['commit', '-m', 'added b'])
452
 
 
453
 
        os.chdir('../a')
454
 
        out = bzr('pull --verbose ../b', backtick=True)
455
 
        self.failIfEqual(out.find('Added Revisions:'), -1)
456
 
        self.failIfEqual(out.find('message:\n  added b'), -1)
457
 
        self.failIfEqual(out.find('added b'), -1)
458
 
 
459
 
        # Check that --overwrite --verbose prints out the removed entries
460
 
        bzr('commit -m foo --unchanged')
461
 
        os.chdir('../b')
462
 
        bzr('commit -m baz --unchanged')
463
 
        bzr('pull ../a', retcode=3)
464
 
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
465
 
 
466
 
        remove_loc = out.find('Removed Revisions:')
467
 
        self.failIfEqual(remove_loc, -1)
468
 
        added_loc = out.find('Added Revisions:')
469
 
        self.failIfEqual(added_loc, -1)
470
 
 
471
 
        removed_message = out.find('message:\n  baz')
472
 
        self.failIfEqual(removed_message, -1)
473
 
        self.failUnless(remove_loc < removed_message < added_loc)
474
 
 
475
 
        added_message = out.find('message:\n  foo')
476
 
        self.failIfEqual(added_message, -1)
477
 
        self.failUnless(added_loc < added_message)
478
 
        
479
 
    def test_locations(self):
480
 
        """Using and remembering different locations"""
481
 
        os.mkdir('a')
482
 
        os.chdir('a')
483
 
        self.runbzr('init')
484
 
        self.runbzr('commit -m unchanged --unchanged')
485
 
        self.runbzr('pull', retcode=3)
486
 
        self.runbzr('merge', retcode=3)
487
 
        self.runbzr('branch . ../b')
488
 
        os.chdir('../b')
489
 
        self.runbzr('pull')
490
 
        self.runbzr('branch . ../c')
491
 
        self.runbzr('pull ../c')
492
 
        self.runbzr('merge')
493
 
        os.chdir('../a')
494
 
        self.runbzr('pull ../b')
495
 
        self.runbzr('pull')
496
 
        self.runbzr('pull ../c')
497
 
        self.runbzr('branch ../c ../d')
498
 
        rmtree('../c')
499
 
        self.runbzr('pull')
500
 
        os.chdir('../b')
501
 
        self.runbzr('pull')
502
 
        os.chdir('../d')
503
 
        self.runbzr('pull', retcode=3)
504
 
        self.runbzr('pull ../a --remember')
505
 
        self.runbzr('pull')
506
 
        
507
 
    def test_unknown_command(self):
508
 
        """Handling of unknown command."""
509
 
        out, err = self.run_bzr_captured(['fluffy-badger'],
510
 
                                         retcode=3)
511
 
        self.assertEquals(out, '')
512
 
        err.index('unknown command')
513
 
 
514
 
    def create_conflicts(self):
515
 
        """Create a conflicted tree"""
516
 
        os.mkdir('base')
517
 
        os.chdir('base')
518
 
        file('hello', 'wb').write("hi world")
519
 
        file('answer', 'wb').write("42")
520
 
        self.runbzr('init')
521
 
        self.runbzr('add')
522
 
        self.runbzr('commit -m base')
523
 
        self.runbzr('branch . ../other')
524
 
        self.runbzr('branch . ../this')
525
 
        os.chdir('../other')
526
 
        file('hello', 'wb').write("Hello.")
527
 
        file('answer', 'wb').write("Is anyone there?")
528
 
        self.runbzr('commit -m other')
529
 
        os.chdir('../this')
530
 
        file('hello', 'wb').write("Hello, world")
531
 
        self.runbzr('mv answer question')
532
 
        file('question', 'wb').write("What do you get when you multiply six"
533
 
                                   "times nine?")
534
 
        self.runbzr('commit -m this')
535
 
 
536
 
    def test_remerge(self):
537
 
        """Remerge command works as expected"""
538
 
        self.create_conflicts()
539
 
        self.runbzr('merge ../other --show-base', retcode=1)
540
 
        conflict_text = file('hello').read()
541
 
        assert '|||||||' in conflict_text
542
 
        assert 'hi world' in conflict_text
543
 
        self.runbzr('remerge', retcode=1)
544
 
        conflict_text = file('hello').read()
545
 
        assert '|||||||' not in conflict_text
546
 
        assert 'hi world' not in conflict_text
547
 
        os.unlink('hello.OTHER')
548
 
        os.unlink('question.OTHER')
549
 
        self.runbzr('remerge jello --merge-type weave', retcode=3)
550
 
        self.runbzr('remerge hello --merge-type weave', retcode=1)
551
 
        assert os.path.exists('hello.OTHER')
552
 
        self.assertIs(False, os.path.exists('question.OTHER'))
553
 
        file_id = self.runbzr('file-id hello')
554
 
        file_id = self.runbzr('file-id hello.THIS', retcode=3)
555
 
        self.runbzr('remerge --merge-type weave', retcode=1)
556
 
        assert os.path.exists('hello.OTHER')
557
 
        assert not os.path.exists('hello.BASE')
558
 
        assert '|||||||' not in conflict_text
559
 
        assert 'hi world' not in conflict_text
560
 
        self.runbzr('remerge . --merge-type weave --show-base', retcode=3)
561
 
        self.runbzr('remerge . --show-base --reprocess', retcode=3)
562
 
        self.runbzr('remerge . --merge-type weave --reprocess', retcode=1)
563
 
        self.runbzr('remerge hello --show-base', retcode=1)
564
 
        self.runbzr('remerge hello --reprocess', retcode=1)
565
 
        self.runbzr('resolve --all')
566
 
        self.runbzr('commit -m done',)
567
 
        self.runbzr('remerge', retcode=3)
568
 
 
569
 
    def test_status(self):
570
 
        os.mkdir('branch1')
571
 
        os.chdir('branch1')
572
 
        self.runbzr('init')
573
 
        self.runbzr('commit --unchanged --message f')
574
 
        self.runbzr('branch . ../branch2')
575
 
        self.runbzr('branch . ../branch3')
576
 
        self.runbzr('commit --unchanged --message peter')
577
 
        os.chdir('../branch2')
578
 
        self.runbzr('merge ../branch1')
579
 
        self.runbzr('commit --unchanged --message pumpkin')
580
 
        os.chdir('../branch3')
581
 
        self.runbzr('merge ../branch2')
582
 
        message = self.capture('status')
583
 
 
584
 
 
585
 
    def test_conflicts(self):
586
 
        """Handling of merge conflicts"""
587
 
        self.create_conflicts()
588
 
        self.runbzr('merge ../other --show-base', retcode=1)
589
 
        conflict_text = file('hello').read()
590
 
        self.assert_('<<<<<<<' in conflict_text)
591
 
        self.assert_('>>>>>>>' in conflict_text)
592
 
        self.assert_('=======' in conflict_text)
593
 
        self.assert_('|||||||' in conflict_text)
594
 
        self.assert_('hi world' in conflict_text)
595
 
        self.runbzr('revert')
596
 
        self.runbzr('resolve --all')
597
 
        self.runbzr('merge ../other', retcode=1)
598
 
        conflict_text = file('hello').read()
599
 
        self.assert_('|||||||' not in conflict_text)
600
 
        self.assert_('hi world' not in conflict_text)
601
 
        result = self.runbzr('conflicts', backtick=1)
602
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
603
 
                                  " question\n")
604
 
        result = self.runbzr('status', backtick=1)
605
 
        self.assert_("conflicts:\n  Text conflict in hello\n"
606
 
                     "  Text conflict in question\n" in result, result)
607
 
        self.runbzr('resolve hello')
608
 
        result = self.runbzr('conflicts', backtick=1)
609
 
        self.assertEquals(result, "Text conflict in question\n")
610
 
        self.runbzr('commit -m conflicts', retcode=3)
611
 
        self.runbzr('resolve --all')
612
 
        result = self.runbzr('conflicts', backtick=1)
613
 
        self.runbzr('commit -m conflicts')
614
 
        self.assertEquals(result, "")
615
 
 
616
 
    def test_push(self):
617
 
        # create a source branch
618
 
        os.mkdir('my-branch')
619
 
        os.chdir('my-branch')
620
 
        self.example_branch()
621
 
 
622
 
        # with no push target, fail
623
 
        self.runbzr('push', retcode=3)
624
 
        # with an explicit target work
625
 
        self.runbzr('push ../output-branch')
626
 
        # with an implicit target work
627
 
        self.runbzr('push')
628
 
        # nothing missing
629
 
        self.runbzr('missing ../output-branch')
630
 
        # advance this branch
631
 
        self.runbzr('commit --unchanged -m unchanged')
632
 
 
633
 
        os.chdir('../output-branch')
634
 
        # There is no longer a difference as long as we have
635
 
        # access to the working tree
636
 
        self.runbzr('diff')
637
 
 
638
 
        # But we should be missing a revision
639
 
        self.runbzr('missing ../my-branch', retcode=1)
640
 
 
641
 
        # diverge the branches
642
 
        self.runbzr('commit --unchanged -m unchanged')
643
 
        os.chdir('../my-branch')
644
 
        # cannot push now
645
 
        self.runbzr('push', retcode=3)
646
 
        # and there are difference
647
 
        self.runbzr('missing ../output-branch', retcode=1)
648
 
        self.runbzr('missing --verbose ../output-branch', retcode=1)
649
 
        # but we can force a push
650
 
        self.runbzr('push --overwrite')
651
 
        # nothing missing
652
 
        self.runbzr('missing ../output-branch')
653
 
        
654
 
        # pushing to a new dir with no parent should fail
655
 
        self.runbzr('push ../missing/new-branch', retcode=3)
656
 
        # unless we provide --create-prefix
657
 
        self.runbzr('push --create-prefix ../missing/new-branch')
658
 
        # nothing missing
659
 
        self.runbzr('missing ../missing/new-branch')
660
 
 
661
 
    def test_external_command(self):
662
 
        """Test that external commands can be run by setting the path
663
 
        """
664
 
        # We don't at present run bzr in a subprocess for blackbox tests, and so 
665
 
        # don't really capture stdout, only the internal python stream.
666
 
        # Therefore we don't use a subcommand that produces any output or does
667
 
        # anything -- we just check that it can be run successfully.  
668
 
        cmd_name = 'test-command'
669
 
        if sys.platform == 'win32':
670
 
            cmd_name += '.bat'
671
 
        oldpath = os.environ.get('BZRPATH', None)
672
 
        bzr = self.capture
673
 
        try:
674
 
            if os.environ.has_key('BZRPATH'):
675
 
                del os.environ['BZRPATH']
676
 
 
677
 
            f = file(cmd_name, 'wb')
678
 
            if sys.platform == 'win32':
679
 
                f.write('@echo off\n')
680
 
            else:
681
 
                f.write('#!/bin/sh\n')
682
 
            # f.write('echo Hello from test-command')
683
 
            f.close()
684
 
            os.chmod(cmd_name, 0755)
685
 
 
686
 
            # It should not find the command in the local 
687
 
            # directory by default, since it is not in my path
688
 
            bzr(cmd_name, retcode=3)
689
 
 
690
 
            # Now put it into my path
691
 
            os.environ['BZRPATH'] = '.'
692
 
 
693
 
            bzr(cmd_name)
694
 
 
695
 
            # Make sure empty path elements are ignored
696
 
            os.environ['BZRPATH'] = os.pathsep
697
 
 
698
 
            bzr(cmd_name, retcode=3)
699
 
 
700
 
        finally:
701
 
            if oldpath:
702
 
                os.environ['BZRPATH'] = oldpath
703
 
 
704
 
 
705
 
def listdir_sorted(dir):
706
 
    L = os.listdir(dir)
707
 
    L.sort()
708
 
    return L
 
193
        self.assertEquals(list(b.unknowns()), [])
 
194
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
195
        
 
196
 
709
197
 
710
198
 
711
199
class OldTests(ExternalBase):
712
 
    """old tests moved from ./testbzr."""
713
 
 
714
 
    def test_bzr(self):
 
200
    # old tests moved from ./testbzr
 
201
    def runTest(self):
715
202
        from os import chdir, mkdir
716
203
        from os.path import exists
 
204
        import os
717
205
 
718
206
        runbzr = self.runbzr
719
 
        capture = self.capture
 
207
        backtick = self.backtick
720
208
        progress = self.log
721
209
 
722
210
        progress("basic branch creation")
724
212
        chdir('branch1')
725
213
        runbzr('init')
726
214
 
727
 
        self.assertEquals(capture('root').rstrip(),
728
 
                          pathjoin(self.test_dir, 'branch1'))
 
215
        self.assertEquals(backtick('bzr root').rstrip(),
 
216
                          os.path.join(self.test_dir, 'branch1'))
729
217
 
730
218
        progress("status of new file")
731
219
 
733
221
        f.write('hello world!\n')
734
222
        f.close()
735
223
 
736
 
        self.assertEquals(capture('unknowns'), 'test.txt\n')
737
 
 
738
 
        out = capture("status")
739
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
740
 
 
741
 
        out = capture("status --all")
742
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
743
 
 
744
 
        out = capture("status test.txt --all")
745
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
224
        out = backtick("bzr unknowns")
 
225
        self.assertEquals(out, 'test.txt\n')
 
226
 
 
227
        out = backtick("bzr status")
 
228
        assert out == 'unknown:\n  test.txt\n'
 
229
 
 
230
        out = backtick("bzr status --all")
 
231
        assert out == "unknown:\n  test.txt\n"
 
232
 
 
233
        out = backtick("bzr status test.txt --all")
 
234
        assert out == "unknown:\n  test.txt\n"
746
235
 
747
236
        f = file('test2.txt', 'wt')
748
237
        f.write('goodbye cruel world...\n')
749
238
        f.close()
750
239
 
751
 
        out = capture("status test.txt")
752
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
240
        out = backtick("bzr status test.txt")
 
241
        assert out == "unknown:\n  test.txt\n"
753
242
 
754
 
        out = capture("status")
755
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
243
        out = backtick("bzr status")
 
244
        assert out == ("unknown:\n"
 
245
                       "  test.txt\n"
 
246
                       "  test2.txt\n")
756
247
 
757
248
        os.unlink('test2.txt')
758
249
 
759
250
        progress("command aliases")
760
 
        out = capture("st --all")
761
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
251
        out = backtick("bzr st --all")
 
252
        assert out == ("unknown:\n"
 
253
                       "  test.txt\n")
762
254
 
763
 
        out = capture("stat")
764
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
255
        out = backtick("bzr stat")
 
256
        assert out == ("unknown:\n"
 
257
                       "  test.txt\n")
765
258
 
766
259
        progress("command help")
767
260
        runbzr("help st")
768
261
        runbzr("help")
769
262
        runbzr("help commands")
770
 
        runbzr("help slartibartfast", 3)
 
263
        runbzr("help slartibartfast", 1)
771
264
 
772
 
        out = capture("help ci")
 
265
        out = backtick("bzr help ci")
773
266
        out.index('aliases: ')
774
267
 
775
268
        progress("can't rename unversioned file")
776
 
        runbzr("rename test.txt new-test.txt", 3)
 
269
        runbzr("rename test.txt new-test.txt", 1)
777
270
 
778
271
        progress("adding a file")
779
272
 
780
273
        runbzr("add test.txt")
781
 
        self.assertEquals(capture("unknowns"), '')
782
 
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
 
274
        assert backtick("bzr unknowns") == ''
 
275
        assert backtick("bzr status --all") == ("added:\n"
 
276
                                                "  test.txt\n")
783
277
 
784
278
        progress("rename newly-added file")
785
279
        runbzr("rename test.txt hello.txt")
786
 
        self.assert_(os.path.exists("hello.txt"))
787
 
        self.assert_(not os.path.exists("test.txt"))
 
280
        assert os.path.exists("hello.txt")
 
281
        assert not os.path.exists("test.txt")
788
282
 
789
 
        self.assertEquals(capture("revno"), '0\n')
 
283
        assert backtick("bzr revno") == '0\n'
790
284
 
791
285
        progress("add first revision")
792
286
        runbzr(['commit', '-m', 'add first revision'])
793
287
 
794
288
        progress("more complex renames")
795
289
        os.mkdir("sub1")
796
 
        runbzr("rename hello.txt sub1", 3)
797
 
        runbzr("rename hello.txt sub1/hello.txt", 3)
798
 
        runbzr("move hello.txt sub1", 3)
 
290
        runbzr("rename hello.txt sub1", 1)
 
291
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
292
        runbzr("move hello.txt sub1", 1)
799
293
 
800
294
        runbzr("add sub1")
801
295
        runbzr("rename sub1 sub2")
802
296
        runbzr("move hello.txt sub2")
803
 
        self.assertEqual(capture("relpath sub2/hello.txt"),
804
 
                         pathjoin("sub2", "hello.txt\n"))
 
297
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
805
298
 
806
 
        self.assert_(exists("sub2"))
807
 
        self.assert_(exists("sub2/hello.txt"))
808
 
        self.assert_(not exists("sub1"))
809
 
        self.assert_(not exists("hello.txt"))
 
299
        assert exists("sub2")
 
300
        assert exists("sub2/hello.txt")
 
301
        assert not exists("sub1")
 
302
        assert not exists("hello.txt")
810
303
 
811
304
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
812
305
 
813
306
        mkdir("sub1")
814
307
        runbzr('add sub1')
815
308
        runbzr('move sub2/hello.txt sub1')
816
 
        self.assert_(not exists('sub2/hello.txt'))
817
 
        self.assert_(exists('sub1/hello.txt'))
 
309
        assert not exists('sub2/hello.txt')
 
310
        assert exists('sub1/hello.txt')
818
311
        runbzr('move sub2 sub1')
819
 
        self.assert_(not exists('sub2'))
820
 
        self.assert_(exists('sub1/sub2'))
 
312
        assert not exists('sub2')
 
313
        assert exists('sub1/sub2')
821
314
 
822
315
        runbzr(['commit', '-m', 'rename nested subdirectories'])
823
316
 
824
317
        chdir('sub1/sub2')
825
 
        self.assertEquals(capture('root')[:-1],
826
 
                          pathjoin(self.test_dir, 'branch1'))
 
318
        self.assertEquals(backtick('bzr root')[:-1],
 
319
                          os.path.join(self.test_dir, 'branch1'))
827
320
        runbzr('move ../hello.txt .')
828
 
        self.assert_(exists('./hello.txt'))
829
 
        self.assertEquals(capture('relpath hello.txt'),
830
 
                          pathjoin('sub1', 'sub2', 'hello.txt') + '\n')
831
 
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
321
        assert exists('./hello.txt')
 
322
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
323
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
832
324
        runbzr(['commit', '-m', 'move to parent directory'])
833
325
        chdir('..')
834
 
        self.assertEquals(capture('relpath sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
326
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
835
327
 
836
328
        runbzr('move sub2/hello.txt .')
837
 
        self.assert_(exists('hello.txt'))
 
329
        assert exists('hello.txt')
838
330
 
839
331
        f = file('hello.txt', 'wt')
840
332
        f.write('some nice new content\n')
841
333
        f.close()
842
334
 
843
335
        f = file('msg.tmp', 'wt')
844
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
336
        f.write('this is my new commit\n')
845
337
        f.close()
846
338
 
847
339
        runbzr('commit -F msg.tmp')
848
340
 
849
 
        self.assertEquals(capture('revno'), '5\n')
 
341
        assert backtick('bzr revno') == '5\n'
850
342
        runbzr('export -r 5 export-5.tmp')
851
343
        runbzr('export export.tmp')
852
344
 
853
345
        runbzr('log')
854
346
        runbzr('log -v')
855
347
        runbzr('log -v --forward')
856
 
        runbzr('log -m', retcode=3)
857
 
        log_out = capture('log -m commit')
858
 
        self.assert_("this is my new commit\n  and" in log_out)
859
 
        self.assert_("rename nested" not in log_out)
860
 
        self.assert_('revision-id' not in log_out)
861
 
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
348
        runbzr('log -m', retcode=1)
 
349
        log_out = backtick('bzr log -m commit')
 
350
        assert "this is my new commit" in log_out
 
351
        assert "rename nested" not in log_out
 
352
        assert 'revision-id' not in log_out
 
353
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
862
354
 
863
 
        log_out = capture('log --line')
864
 
        # determine the widest line we want
865
 
        max_width = terminal_width() - 1
866
 
        for line in log_out.splitlines():
867
 
            self.assert_(len(line) <= max_width, len(line))
868
 
        self.assert_("this is my new commit and" in log_out)
869
355
 
870
356
        progress("file with spaces in name")
871
357
        mkdir('sub directory')
872
358
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
873
359
        runbzr('add .')
874
 
        runbzr('diff', retcode=1)
 
360
        runbzr('diff')
875
361
        runbzr('commit -m add-spaces')
876
362
        runbzr('check')
877
363
 
880
366
 
881
367
        runbzr('info')
882
368
 
883
 
        if has_symlinks():
884
 
            progress("symlinks")
885
 
            mkdir('symlinks')
886
 
            chdir('symlinks')
887
 
            runbzr('init')
888
 
            os.symlink("NOWHERE1", "link1")
889
 
            runbzr('add link1')
890
 
            self.assertEquals(self.capture('unknowns'), '')
891
 
            runbzr(['commit', '-m', '1: added symlink link1'])
892
 
    
893
 
            mkdir('d1')
894
 
            runbzr('add d1')
895
 
            self.assertEquals(self.capture('unknowns'), '')
896
 
            os.symlink("NOWHERE2", "d1/link2")
897
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
898
 
            # is d1/link2 found when adding d1
899
 
            runbzr('add d1')
900
 
            self.assertEquals(self.capture('unknowns'), '')
901
 
            os.symlink("NOWHERE3", "d1/link3")
902
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
903
 
            runbzr(['commit', '-m', '2: added dir, symlink'])
904
 
    
905
 
            runbzr('rename d1 d2')
906
 
            runbzr('move d2/link2 .')
907
 
            runbzr('move link1 d2')
908
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
909
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
910
 
            runbzr('add d2/link3')
911
 
            runbzr('diff', retcode=1)
912
 
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
913
 
    
914
 
            os.unlink("link2")
915
 
            os.symlink("TARGET 2", "link2")
916
 
            os.unlink("d2/link1")
917
 
            os.symlink("TARGET 1", "d2/link1")
918
 
            runbzr('diff', retcode=1)
919
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
920
 
            runbzr(['commit', '-m', '4: retarget of two links'])
921
 
    
922
 
            runbzr('remove d2/link1')
923
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
924
 
            runbzr(['commit', '-m', '5: remove d2/link1'])
925
 
            # try with the rm alias
926
 
            runbzr('add d2/link1')
927
 
            runbzr(['commit', '-m', '6: add d2/link1'])
928
 
            runbzr('rm d2/link1')
929
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
930
 
            runbzr(['commit', '-m', '7: remove d2/link1'])
931
 
    
932
 
            os.mkdir("d1")
933
 
            runbzr('add d1')
934
 
            runbzr('rename d2/link3 d1/link3new')
935
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
936
 
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
937
 
            
938
 
            runbzr(['check'])
939
 
            
940
 
            runbzr(['export', '-r', '1', 'exp1.tmp'])
941
 
            chdir("exp1.tmp")
942
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
943
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
944
 
            chdir("..")
945
 
            
946
 
            runbzr(['export', '-r', '2', 'exp2.tmp'])
947
 
            chdir("exp2.tmp")
948
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
949
 
            chdir("..")
950
 
            
951
 
            runbzr(['export', '-r', '3', 'exp3.tmp'])
952
 
            chdir("exp3.tmp")
953
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
954
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
955
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
956
 
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
957
 
            chdir("..")
958
 
            
959
 
            runbzr(['export', '-r', '4', 'exp4.tmp'])
960
 
            chdir("exp4.tmp")
961
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
962
 
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
963
 
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
964
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
965
 
            chdir("..")
966
 
            
967
 
            runbzr(['export', '-r', '5', 'exp5.tmp'])
968
 
            chdir("exp5.tmp")
969
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
970
 
            self.assert_(os.path.islink("link2"))
971
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
972
 
            chdir("..")
973
 
            
974
 
            runbzr(['export', '-r', '8', 'exp6.tmp'])
975
 
            chdir("exp6.tmp")
976
 
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
977
 
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
978
 
            self.assertEquals(listdir_sorted("d2"), [])
979
 
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
980
 
            chdir("..")
981
 
        else:
982
 
            progress("skipping symlink tests")
983
 
 
984
 
 
985
 
class RemoteTests(object):
986
 
    """Test bzr ui commands against remote branches."""
987
 
 
988
 
    def test_branch(self):
989
 
        os.mkdir('from')
990
 
        wt = self.make_branch_and_tree('from')
991
 
        branch = wt.branch
992
 
        wt.commit('empty commit for nonsense', allow_pointless=True)
993
 
        url = self.get_readonly_url('from')
994
 
        self.run_bzr('branch', url, 'to')
995
 
        branch = Branch.open('to')
996
 
        self.assertEqual(1, len(branch.revision_history()))
997
 
        # the branch should be set in to to from
998
 
        self.assertEqual(url + '/', branch.get_parent())
999
 
 
1000
 
    def test_log(self):
1001
 
        self.build_tree(['branch/', 'branch/file'])
1002
 
        self.capture('init branch')
1003
 
        self.capture('add branch/file')
1004
 
        self.capture('commit -m foo branch')
1005
 
        url = self.get_readonly_url('branch/file')
1006
 
        output = self.capture('log %s' % url)
1007
 
        self.assertEqual(8, len(output.split('\n')))
 
369
 
 
370
 
 
371
 
 
372
 
 
373
 
 
374
class RevertCommand(ExternalBase):
 
375
    def runTest(self):
 
376
        self.runbzr('init')
 
377
 
 
378
        file('hello', 'wt').write('foo')
 
379
        self.runbzr('add hello')
 
380
        self.runbzr('commit -m setup hello')
 
381
 
 
382
        file('goodbye', 'wt').write('baz')
 
383
        self.runbzr('add goodbye')
 
384
        self.runbzr('commit -m setup goodbye')
1008
385
        
1009
 
    def test_check(self):
1010
 
        self.build_tree(['branch/', 'branch/file'])
1011
 
        self.capture('init branch')
1012
 
        self.capture('add branch/file')
1013
 
        self.capture('commit -m foo branch')
1014
 
        url = self.get_readonly_url('branch/')
1015
 
        self.run_bzr('check', url)
1016
 
    
1017
 
    def test_push(self):
1018
 
        # create a source branch
1019
 
        os.mkdir('my-branch')
1020
 
        os.chdir('my-branch')
1021
 
        self.run_bzr('init')
1022
 
        file('hello', 'wt').write('foo')
1023
 
        self.run_bzr('add', 'hello')
1024
 
        self.run_bzr('commit', '-m', 'setup')
1025
 
 
1026
 
        # with an explicit target work
1027
 
        self.run_bzr('push', self.get_url('output-branch'))
1028
 
 
1029
 
    
1030
 
class HTTPTests(TestCaseWithWebserver, RemoteTests):
1031
 
    """Test various commands against a HTTP server."""
1032
 
    
1033
 
    
1034
 
class SFTPTestsAbsolute(TestCaseWithSFTPServer, RemoteTests):
1035
 
    """Test various commands against a SFTP server using abs paths."""
1036
 
 
1037
 
    
1038
 
class SFTPTestsAbsoluteSibling(TestCaseWithSFTPServer, RemoteTests):
1039
 
    """Test various commands against a SFTP server using abs paths."""
1040
 
 
1041
 
    def setUp(self):
1042
 
        super(SFTPTestsAbsoluteSibling, self).setUp()
1043
 
        self._override_home = '/dev/noone/runs/tests/here'
1044
 
 
1045
 
    
1046
 
class SFTPTestsRelative(TestCaseWithSFTPServer, RemoteTests):
1047
 
    """Test various commands against a SFTP server using homedir rel paths."""
1048
 
 
1049
 
    def setUp(self):
1050
 
        super(SFTPTestsRelative, self).setUp()
1051
 
        self._get_remote_is_absolute = False
 
386
        file('hello', 'wt').write('bar')
 
387
        file('goodbye', 'wt').write('qux')
 
388
        self.runbzr('revert hello')
 
389
        self.check_file_contents('hello', 'foo')
 
390
        self.check_file_contents('goodbye', 'qux')
 
391
        self.runbzr('revert')
 
392
        self.check_file_contents('goodbye', 'baz')
 
393