/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/tests/blackbox/test_selftest.py

  • Committer: Aaron Bentley
  • Date: 2006-09-28 13:48:10 UTC
  • mfrom: (2049 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20060928134810-2c8ae086a4a70f43
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_selftest.py
15
15
 
16
16
"""UI tests for the test framework."""
17
17
 
 
18
import os
 
19
import signal
18
20
import sys
19
21
 
20
22
import bzrlib
 
23
from bzrlib import (
 
24
    osutils,
 
25
    )
21
26
from bzrlib.errors import ParamikoNotPresent
22
27
from bzrlib.tests import (
23
28
                          TestCase,
81
86
 
82
87
class TestRunBzr(ExternalBase):
83
88
 
84
 
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None):
 
89
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
 
90
                         working_dir=None):
 
91
        """Override run_bzr_captured to test how it is invoked by run_bzr.
 
92
 
 
93
        We test how run_bzr_captured actually invokes bzr in another location.
 
94
        Here we only need to test that it is run_bzr passes the right
 
95
        parameters to run_bzr_captured.
 
96
        """
 
97
        self.argv = argv
 
98
        self.retcode = retcode
 
99
        self.encoding = encoding
85
100
        self.stdin = stdin
 
101
        self.working_dir = working_dir
 
102
 
 
103
    def test_args(self):
 
104
        """Test that run_bzr passes args correctly to run_bzr_captured"""
 
105
        self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
 
106
        self.assertEqual(('arg1', 'arg2', 'arg3'), self.argv)
 
107
 
 
108
    def test_encoding(self):
 
109
        """Test that run_bzr passes encoding to run_bzr_captured"""
 
110
        self.run_bzr('foo', 'bar')
 
111
        self.assertEqual(None, self.encoding)
 
112
        self.assertEqual(('foo', 'bar'), self.argv)
 
113
 
 
114
        self.run_bzr('foo', 'bar', encoding='baz')
 
115
        self.assertEqual('baz', self.encoding)
 
116
        self.assertEqual(('foo', 'bar'), self.argv)
 
117
 
 
118
    def test_retcode(self):
 
119
        """Test that run_bzr passes retcode to run_bzr_captured"""
 
120
        # Default is retcode == 0
 
121
        self.run_bzr('foo', 'bar')
 
122
        self.assertEqual(0, self.retcode)
 
123
        self.assertEqual(('foo', 'bar'), self.argv)
 
124
 
 
125
        self.run_bzr('foo', 'bar', retcode=1)
 
126
        self.assertEqual(1, self.retcode)
 
127
        self.assertEqual(('foo', 'bar'), self.argv)
 
128
 
 
129
        self.run_bzr('foo', 'bar', retcode=None)
 
130
        self.assertEqual(None, self.retcode)
 
131
        self.assertEqual(('foo', 'bar'), self.argv)
 
132
 
 
133
        self.run_bzr('foo', 'bar', retcode=3)
 
134
        self.assertEqual(3, self.retcode)
 
135
        self.assertEqual(('foo', 'bar'), self.argv)
86
136
 
87
137
    def test_stdin(self):
88
138
        # test that the stdin keyword to run_bzr is passed through to
92
142
        # should invoke it.
93
143
        self.run_bzr('foo', 'bar', stdin='gam')
94
144
        self.assertEqual('gam', self.stdin)
 
145
        self.assertEqual(('foo', 'bar'), self.argv)
 
146
 
95
147
        self.run_bzr('foo', 'bar', stdin='zippy')
96
148
        self.assertEqual('zippy', self.stdin)
 
149
        self.assertEqual(('foo', 'bar'), self.argv)
 
150
 
 
151
    def test_working_dir(self):
 
152
        """Test that run_bzr passes working_dir to run_bzr_captured"""
 
153
        self.run_bzr('foo', 'bar')
 
154
        self.assertEqual(None, self.working_dir)
 
155
        self.assertEqual(('foo', 'bar'), self.argv)
 
156
 
 
157
        self.run_bzr('foo', 'bar', working_dir='baz')
 
158
        self.assertEqual('baz', self.working_dir)
 
159
        self.assertEqual(('foo', 'bar'), self.argv)
97
160
 
98
161
 
99
162
class TestBenchmarkTests(TestCaseWithTransport):
128
191
        self.stdin = stdin
129
192
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
130
193
        self.factory = bzrlib.ui.ui_factory
 
194
        self.working_dir = osutils.getcwd()
131
195
        stdout.write('foo\n')
132
196
        stderr.write('bar\n')
133
197
        return 0
158
222
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
159
223
        self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
160
224
 
 
225
    def test_working_dir(self):
 
226
        self.build_tree(['one/', 'two/'])
 
227
        cwd = osutils.getcwd()
 
228
 
 
229
        # Default is to work in the current directory
 
230
        self.run_bzr_captured(['foo', 'bar'])
 
231
        self.assertEqual(cwd, self.working_dir)
 
232
 
 
233
        self.run_bzr_captured(['foo', 'bar'], working_dir=None)
 
234
        self.assertEqual(cwd, self.working_dir)
 
235
 
 
236
        # The function should be run in the alternative directory
 
237
        # but afterwards the current working dir shouldn't be changed
 
238
        self.run_bzr_captured(['foo', 'bar'], working_dir='one')
 
239
        self.assertNotEqual(cwd, self.working_dir)
 
240
        self.assertEndsWith(self.working_dir, 'one')
 
241
        self.assertEqual(cwd, osutils.getcwd())
 
242
 
 
243
        self.run_bzr_captured(['foo', 'bar'], working_dir='two')
 
244
        self.assertNotEqual(cwd, self.working_dir)
 
245
        self.assertEndsWith(self.working_dir, 'two')
 
246
        self.assertEqual(cwd, osutils.getcwd())
 
247
 
 
248
 
 
249
class TestRunBzrSubprocess(TestCaseWithTransport):
 
250
 
161
251
    def test_run_bzr_subprocess(self):
162
252
        """The run_bzr_helper_external comand behaves nicely."""
163
253
        result = self.run_bzr_subprocess('--version')
172
262
                                      retcode=3)[1]
173
263
        self.assertContainsRe(err, 'No known merge type magic merge')
174
264
 
 
265
    def test_run_bzr_subprocess_env(self):
 
266
        """run_bzr_subprocess can set environment variables in the child only.
 
267
 
 
268
        These changes should not change the running process, only the child.
 
269
        """
 
270
        # The test suite should unset this variable
 
271
        self.assertEqual(None, os.environ.get('BZR_EMAIL'))
 
272
        out, err = self.run_bzr_subprocess('whoami', env_changes={
 
273
                                            'BZR_EMAIL':'Joe Foo <joe@foo.com>'
 
274
                                          }, universal_newlines=True)
 
275
        self.assertEqual('', err)
 
276
        self.assertEqual('Joe Foo <joe@foo.com>\n', out)
 
277
        # And it should not be modified
 
278
        self.assertEqual(None, os.environ.get('BZR_EMAIL'))
 
279
 
 
280
        # Do it again with a different address, just to make sure
 
281
        # it is actually changing
 
282
        out, err = self.run_bzr_subprocess('whoami', env_changes={
 
283
                                            'BZR_EMAIL':'Barry <bar@foo.com>'
 
284
                                          }, universal_newlines=True)
 
285
        self.assertEqual('', err)
 
286
        self.assertEqual('Barry <bar@foo.com>\n', out)
 
287
        self.assertEqual(None, os.environ.get('BZR_EMAIL'))
 
288
 
 
289
    def test_run_bzr_subprocess_env_del(self):
 
290
        """run_bzr_subprocess can remove environment variables too."""
 
291
        # Create a random email, so we are sure this won't collide
 
292
        rand_bzr_email = 'John Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
 
293
        rand_email = 'Jane Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
 
294
        os.environ['BZR_EMAIL'] = rand_bzr_email
 
295
        os.environ['EMAIL'] = rand_email
 
296
        try:
 
297
            # By default, the child will inherit the current env setting
 
298
            out, err = self.run_bzr_subprocess('whoami', universal_newlines=True)
 
299
            self.assertEqual('', err)
 
300
            self.assertEqual(rand_bzr_email + '\n', out)
 
301
 
 
302
            # Now that BZR_EMAIL is not set, it should fall back to EMAIL
 
303
            out, err = self.run_bzr_subprocess('whoami',
 
304
                                               env_changes={'BZR_EMAIL':None},
 
305
                                               universal_newlines=True)
 
306
            self.assertEqual('', err)
 
307
            self.assertEqual(rand_email + '\n', out)
 
308
 
 
309
            # This switches back to the default email guessing logic
 
310
            # Which shouldn't match either of the above addresses
 
311
            out, err = self.run_bzr_subprocess('whoami',
 
312
                           env_changes={'BZR_EMAIL':None, 'EMAIL':None},
 
313
                           universal_newlines=True)
 
314
 
 
315
            self.assertEqual('', err)
 
316
            self.assertNotEqual(rand_bzr_email + '\n', out)
 
317
            self.assertNotEqual(rand_email + '\n', out)
 
318
        finally:
 
319
            # TestCase cleans up BZR_EMAIL, and EMAIL at startup
 
320
            del os.environ['BZR_EMAIL']
 
321
            del os.environ['EMAIL']
 
322
 
 
323
    def test_run_bzr_subprocess_env_del_missing(self):
 
324
        """run_bzr_subprocess won't fail if deleting a nonexistant env var"""
 
325
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
 
326
        out, err = self.run_bzr_subprocess('rocks',
 
327
                        env_changes={'NON_EXISTANT_ENV_VAR':None},
 
328
                        universal_newlines=True)
 
329
        self.assertEqual('it sure does!\n', out)
 
330
        self.assertEqual('', err)
 
331
 
 
332
    def test_run_bzr_subprocess_working_dir(self):
 
333
        """Test that we can specify the working dir for the child"""
 
334
        cwd = osutils.getcwd()
 
335
 
 
336
        self.make_branch_and_tree('.')
 
337
        self.make_branch_and_tree('one')
 
338
        self.make_branch_and_tree('two')
 
339
 
 
340
        def get_root(**kwargs):
 
341
            """Spawn a process to get the 'root' of the tree.
 
342
 
 
343
            You can pass in arbitrary new arguments. This just makes
 
344
            sure that the returned path doesn't have trailing whitespace.
 
345
            """
 
346
            return self.run_bzr_subprocess('root', **kwargs)[0].rstrip()
 
347
 
 
348
        self.assertEqual(cwd, get_root())
 
349
        self.assertEqual(cwd, get_root(working_dir=None))
 
350
        # Has our path changed?
 
351
        self.assertEqual(cwd, osutils.getcwd())
 
352
 
 
353
        dir1 = get_root(working_dir='one')
 
354
        self.assertEndsWith(dir1, 'one')
 
355
        self.assertEqual(cwd, osutils.getcwd())
 
356
 
 
357
        dir2 = get_root(working_dir='two')
 
358
        self.assertEndsWith(dir2, 'two')
 
359
        self.assertEqual(cwd, osutils.getcwd())
 
360
 
 
361
 
 
362
class TestBzrSubprocess(TestCaseWithTransport):
 
363
 
 
364
    def test_start_and_stop_bzr_subprocess(self):
 
365
        """We can start and perform other test actions while that process is
 
366
        still alive.
 
367
        """
 
368
        process = self.start_bzr_subprocess(['--version'])
 
369
        result = self.finish_bzr_subprocess(process)
 
370
        self.assertContainsRe(result[0], 'is free software')
 
371
        self.assertEqual('', result[1])
 
372
 
 
373
    def test_start_and_stop_bzr_subprocess_with_error(self):
 
374
        """finish_bzr_subprocess allows specification of the desired exit code.
 
375
        """
 
376
        process = self.start_bzr_subprocess(['--versionn'])
 
377
        result = self.finish_bzr_subprocess(process, retcode=3)
 
378
        self.assertEqual('', result[0])
 
379
        self.assertContainsRe(result[1], 'unknown command')
 
380
 
 
381
    def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
 
382
        """finish_bzr_subprocess allows the exit code to be ignored."""
 
383
        process = self.start_bzr_subprocess(['--versionn'])
 
384
        result = self.finish_bzr_subprocess(process, retcode=None)
 
385
        self.assertEqual('', result[0])
 
386
        self.assertContainsRe(result[1], 'unknown command')
 
387
 
 
388
    def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
 
389
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
390
        not the expected one.
 
391
        """
 
392
        process = self.start_bzr_subprocess(['--versionn'])
 
393
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
 
394
                          process, retcode=0)
 
395
        
 
396
    def test_start_and_stop_bzr_subprocess_send_signal(self):
 
397
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
398
        not the expected one.
 
399
        """
 
400
        process = self.start_bzr_subprocess(['wait-until-signalled'],
 
401
                                            skip_if_plan_to_signal=True)
 
402
        self.assertEqual('running\n', process.stdout.readline())
 
403
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
 
404
                                            retcode=3)
 
405
        self.assertEqual('', result[0])
 
406
        self.assertEqual('bzr: interrupted\n', result[1])
 
407
 
 
408
    def test_start_and_stop_working_dir(self):
 
409
        cwd = osutils.getcwd()
 
410
 
 
411
        self.make_branch_and_tree('one')
 
412
 
 
413
        process = self.start_bzr_subprocess(['root'], working_dir='one')
 
414
        result = self.finish_bzr_subprocess(process)
 
415
        self.assertEndsWith(result[0], 'one\n')
 
416
        self.assertEqual('', result[1])
 
417
        
175
418
 
176
419
class TestRunBzrError(ExternalBase):
177
420