← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-05-03 19:49:12 UTC
  • mfrom: (2476.1.1 shared_repo_layouts)
  • Revision ID: pqm@pqm.ubuntu.com-20070503194912-pzlcms91kk2uqfdo
(John Arbash Meinel) Add doc/shared_repository_layouts.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License version 2 as published by
5
 
# the Free Software Foundation.
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
6
7
#
7
8
# This program is distributed in the hope that it will be useful,
8
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
15
16
 
16
17
"""Tests for the test framework."""
17
18
 
 
19
import cStringIO
18
20
import os
19
21
from StringIO import StringIO
20
22
import sys
23
25
import warnings
24
26
 
25
27
import bzrlib
 
28
from bzrlib import (
 
29
    bzrdir,
 
30
    errors,
 
31
    memorytree,
 
32
    osutils,
 
33
    repository,
 
34
    symbol_versioning,
 
35
    )
26
36
from bzrlib.progress import _BaseProgressBar
 
37
from bzrlib.repofmt import weaverepo
 
38
from bzrlib.symbol_versioning import zero_ten, zero_eleven
27
39
from bzrlib.tests import (
28
40
                          ChrootedTestCase,
 
41
                          ExtendedTestResult,
 
42
                          Feature,
 
43
                          KnownFailure,
29
44
                          TestCase,
30
45
                          TestCaseInTempDir,
 
46
                          TestCaseWithMemoryTransport,
31
47
                          TestCaseWithTransport,
32
48
                          TestSkipped,
33
49
                          TestSuite,
 
50
                          TestUtil,
34
51
                          TextTestRunner,
 
52
                          UnavailableFeature,
 
53
                          clean_selftest_output,
 
54
                          iter_suite_tests,
 
55
                          filter_suite_by_re,
 
56
                          sort_suite_by_re,
 
57
                          test_suite
35
58
                          )
 
59
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
36
60
from bzrlib.tests.TestUtil import _load_module_by_name
37
 
import bzrlib.errors as errors
 
61
from bzrlib.trace import note
 
62
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
63
from bzrlib.version import _get_bzr_source_tree
38
64
 
39
65
 
40
66
class SelftestTests(TestCase):
48
74
                          _load_module_by_name,
49
75
                          'bzrlib.no-name-yet')
50
76
 
51
 
 
52
77
class MetaTestLog(TestCase):
53
78
 
54
79
    def test_logging(self):
55
80
        """Test logs are captured when a test fails."""
56
81
        self.log('a test message')
57
82
        self._log_file.flush()
58
 
        self.assertContainsRe(self._get_log(), 'a test message\n')
 
83
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
84
                              'a test message\n')
59
85
 
60
86
 
61
87
class TestTreeShape(TestCaseInTempDir):
172
198
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
173
199
        input_test = TestBzrDirProviderAdapter(
174
200
            "test_adapted_tests")
 
201
        vfs_factory = "v"
175
202
        server1 = "a"
176
203
        server2 = "b"
177
204
        formats = ["c", "d"]
178
 
        adapter = BzrDirTestProviderAdapter(server1, server2, formats)
 
205
        adapter = BzrDirTestProviderAdapter(vfs_factory,
 
206
            server1, server2, formats)
179
207
        suite = adapter.adapt(input_test)
180
208
        tests = list(iter(suite))
181
209
        self.assertEqual(2, len(tests))
182
210
        self.assertEqual(tests[0].bzrdir_format, formats[0])
 
211
        self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
183
212
        self.assertEqual(tests[0].transport_server, server1)
184
213
        self.assertEqual(tests[0].transport_readonly_server, server2)
185
214
        self.assertEqual(tests[1].bzrdir_format, formats[1])
 
215
        self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
186
216
        self.assertEqual(tests[1].transport_server, server1)
187
217
        self.assertEqual(tests[1].transport_readonly_server, server2)
188
218
 
212
242
        self.assertEqual(tests[1].transport_server, server1)
213
243
        self.assertEqual(tests[1].transport_readonly_server, server2)
214
244
 
 
245
    def test_setting_vfs_transport(self):
 
246
        """The vfs_transport_factory can be set optionally."""
 
247
        from bzrlib.repository import RepositoryTestProviderAdapter
 
248
        input_test = TestRepositoryProviderAdapter(
 
249
            "test_adapted_tests")
 
250
        formats = [("c", "C")]
 
251
        adapter = RepositoryTestProviderAdapter(None, None, formats,
 
252
            vfs_transport_factory="vfs")
 
253
        suite = adapter.adapt(input_test)
 
254
        tests = list(iter(suite))
 
255
        self.assertEqual(1, len(tests))
 
256
        self.assertEqual(tests[0].vfs_transport_factory, "vfs")
 
257
 
215
258
 
216
259
class TestInterRepositoryProviderAdapter(TestCase):
217
260
    """A group of tests that test the InterRepository test adapter."""
322
365
        self.assertEqual(tests[1].transport_readonly_server, server2)
323
366
 
324
367
 
 
368
class TestTreeProviderAdapter(TestCase):
 
369
    """Test the setup of tree_implementation tests."""
 
370
 
 
371
    def test_adapted_tests(self):
 
372
        # the tree implementation adapter is meant to setup one instance for
 
373
        # each working tree format, and one additional instance that will
 
374
        # use the default wt format, but create a revision tree for the tests.
 
375
        # this means that the wt ones should have the workingtree_to_test_tree
 
376
        # attribute set to 'return_parameter' and the revision one set to
 
377
        # revision_tree_from_workingtree.
 
378
 
 
379
        from bzrlib.tests.tree_implementations import (
 
380
            TreeTestProviderAdapter,
 
381
            return_parameter,
 
382
            revision_tree_from_workingtree
 
383
            )
 
384
        from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
 
385
        input_test = TestTreeProviderAdapter(
 
386
            "test_adapted_tests")
 
387
        server1 = "a"
 
388
        server2 = "b"
 
389
        formats = [("c", "C"), ("d", "D")]
 
390
        adapter = TreeTestProviderAdapter(server1, server2, formats)
 
391
        suite = adapter.adapt(input_test)
 
392
        tests = list(iter(suite))
 
393
        self.assertEqual(4, len(tests))
 
394
        # this must match the default format setp up in
 
395
        # TreeTestProviderAdapter.adapt
 
396
        default_format = WorkingTreeFormat3
 
397
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
398
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
399
        self.assertEqual(tests[0].transport_server, server1)
 
400
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
401
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
402
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
403
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
404
        self.assertEqual(tests[1].transport_server, server1)
 
405
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
406
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
407
        self.assertIsInstance(tests[2].workingtree_format, default_format)
 
408
        #self.assertEqual(tests[2].bzrdir_format,
 
409
        #                 default_format._matchingbzrdir)
 
410
        self.assertEqual(tests[2].transport_server, server1)
 
411
        self.assertEqual(tests[2].transport_readonly_server, server2)
 
412
        self.assertEqual(tests[2].workingtree_to_test_tree,
 
413
            revision_tree_from_workingtree)
 
414
 
 
415
 
 
416
class TestInterTreeProviderAdapter(TestCase):
 
417
    """A group of tests that test the InterTreeTestAdapter."""
 
418
 
 
419
    def test_adapted_tests(self):
 
420
        # check that constructor parameters are passed through to the adapted
 
421
        # test.
 
422
        # for InterTree tests we want the machinery to bring up two trees in
 
423
        # each instance: the base one, and the one we are interacting with.
 
424
        # because each optimiser can be direction specific, we need to test
 
425
        # each optimiser in its chosen direction.
 
426
        # unlike the TestProviderAdapter we dont want to automatically add a
 
427
        # parameterised one for WorkingTree - the optimisers will tell us what
 
428
        # ones to add.
 
429
        from bzrlib.tests.tree_implementations import (
 
430
            return_parameter,
 
431
            revision_tree_from_workingtree
 
432
            )
 
433
        from bzrlib.tests.intertree_implementations import (
 
434
            InterTreeTestProviderAdapter,
 
435
            )
 
436
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
 
437
        input_test = TestInterTreeProviderAdapter(
 
438
            "test_adapted_tests")
 
439
        server1 = "a"
 
440
        server2 = "b"
 
441
        format1 = WorkingTreeFormat2()
 
442
        format2 = WorkingTreeFormat3()
 
443
        formats = [(str, format1, format2, "converter1"),
 
444
            (int, format2, format1, "converter2")]
 
445
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
 
446
        suite = adapter.adapt(input_test)
 
447
        tests = list(iter(suite))
 
448
        self.assertEqual(2, len(tests))
 
449
        self.assertEqual(tests[0].intertree_class, formats[0][0])
 
450
        self.assertEqual(tests[0].workingtree_format, formats[0][1])
 
451
        self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
 
452
        self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
 
453
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
454
        self.assertEqual(tests[0].transport_server, server1)
 
455
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
456
        self.assertEqual(tests[1].intertree_class, formats[1][0])
 
457
        self.assertEqual(tests[1].workingtree_format, formats[1][1])
 
458
        self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
 
459
        self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
 
460
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
461
        self.assertEqual(tests[1].transport_server, server1)
 
462
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
463
 
 
464
 
 
465
class TestTestCaseInTempDir(TestCaseInTempDir):
 
466
 
 
467
    def test_home_is_not_working(self):
 
468
        self.assertNotEqual(self.test_dir, self.test_home_dir)
 
469
        cwd = osutils.getcwd()
 
470
        self.assertEqual(self.test_dir, cwd)
 
471
        self.assertEqual(self.test_home_dir, os.environ['HOME'])
 
472
 
 
473
 
 
474
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
 
475
 
 
476
    def test_home_is_non_existant_dir_under_root(self):
 
477
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
 
478
 
 
479
        This is because TestCaseWithMemoryTransport is for tests that do not
 
480
        need any disk resources: they should be hooked into bzrlib in such a 
 
481
        way that no global settings are being changed by the test (only a 
 
482
        few tests should need to do that), and having a missing dir as home is
 
483
        an effective way to ensure that this is the case.
 
484
        """
 
485
        self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
 
486
            self.test_home_dir)
 
487
        self.assertEqual(self.test_home_dir, os.environ['HOME'])
 
488
        
 
489
    def test_cwd_is_TEST_ROOT(self):
 
490
        self.assertEqual(self.test_dir, self.TEST_ROOT)
 
491
        cwd = osutils.getcwd()
 
492
        self.assertEqual(self.test_dir, cwd)
 
493
 
 
494
    def test_make_branch_and_memory_tree(self):
 
495
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
 
496
 
 
497
        This is hard to comprehensively robustly test, so we settle for making
 
498
        a branch and checking no directory was created at its relpath.
 
499
        """
 
500
        tree = self.make_branch_and_memory_tree('dir')
 
501
        # Guard against regression into MemoryTransport leaking
 
502
        # files to disk instead of keeping them in memory.
 
503
        self.failIf(osutils.lexists('dir'))
 
504
        self.assertIsInstance(tree, memorytree.MemoryTree)
 
505
 
 
506
    def test_make_branch_and_memory_tree_with_format(self):
 
507
        """make_branch_and_memory_tree should accept a format option."""
 
508
        format = bzrdir.BzrDirMetaFormat1()
 
509
        format.repository_format = weaverepo.RepositoryFormat7()
 
510
        tree = self.make_branch_and_memory_tree('dir', format=format)
 
511
        # Guard against regression into MemoryTransport leaking
 
512
        # files to disk instead of keeping them in memory.
 
513
        self.failIf(osutils.lexists('dir'))
 
514
        self.assertIsInstance(tree, memorytree.MemoryTree)
 
515
        self.assertEqual(format.repository_format.__class__,
 
516
            tree.branch.repository._format.__class__)
 
517
 
 
518
 
325
519
class TestTestCaseWithTransport(TestCaseWithTransport):
326
520
    """Tests for the convenience functions TestCaseWithTransport introduces."""
327
521
 
329
523
        from bzrlib.transport import get_transport
330
524
        from bzrlib.transport.memory import MemoryServer
331
525
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
332
 
        self.transport_server = MemoryServer
 
526
        self.vfs_transport_factory = MemoryServer
333
527
        self.transport_readonly_server = None
334
528
        # calling get_readonly_transport() constructs a decorator on the url
335
529
        # for the server
342
536
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
343
537
 
344
538
    def test_get_readonly_url_http(self):
 
539
        from bzrlib.tests.HttpServer import HttpServer
345
540
        from bzrlib.transport import get_transport
346
 
        from bzrlib.transport.local import LocalRelpathServer
347
 
        from bzrlib.transport.http import HttpServer, HttpTransportBase
348
 
        self.transport_server = LocalRelpathServer
 
541
        from bzrlib.transport.local import LocalURLServer
 
542
        from bzrlib.transport.http import HttpTransportBase
 
543
        self.transport_server = LocalURLServer
349
544
        self.transport_readonly_server = HttpServer
350
545
        # calling get_readonly_transport() gives us a HTTP server instance.
351
546
        url = self.get_readonly_url()
366
561
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
367
562
 
368
563
 
 
564
class TestTestCaseTransports(TestCaseWithTransport):
 
565
 
 
566
    def setUp(self):
 
567
        super(TestTestCaseTransports, self).setUp()
 
568
        self.vfs_transport_factory = MemoryServer
 
569
 
 
570
    def test_make_bzrdir_preserves_transport(self):
 
571
        t = self.get_transport()
 
572
        result_bzrdir = self.make_bzrdir('subdir')
 
573
        self.assertIsInstance(result_bzrdir.transport, 
 
574
                              MemoryTransport)
 
575
        # should not be on disk, should only be in memory
 
576
        self.failIfExists('subdir')
 
577
 
 
578
 
369
579
class TestChrootedTest(ChrootedTestCase):
370
580
 
371
581
    def test_root_is_root(self):
394
604
    def clear(self):
395
605
        self.calls.append(('clear',))
396
606
 
 
607
    def note(self, msg, *args):
 
608
        self.calls.append(('note', msg, args))
 
609
 
397
610
 
398
611
class TestTestResult(TestCase):
399
612
 
400
 
    def test_progress_bar_style_quiet(self):
401
 
        # test using a progress bar.
402
 
        dummy_test = TestTestResult('test_progress_bar_style_quiet')
403
 
        dummy_error = (Exception, None, [])
404
 
        mypb = MockProgress()
405
 
        mypb.update('Running tests', 0, 4)
406
 
        last_calls = mypb.calls[:]
407
 
        result = bzrlib.tests._MyResult(self._log_file,
408
 
                                        descriptions=0,
409
 
                                        verbosity=1,
410
 
                                        pb=mypb)
411
 
        self.assertEqual(last_calls, mypb.calls)
412
 
 
413
 
        # an error 
414
 
        result.startTest(dummy_test)
415
 
        # starting a test prints the test name
416
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 0, None)], mypb.calls)
417
 
        last_calls = mypb.calls[:]
418
 
        result.addError(dummy_test, dummy_error)
419
 
        self.assertEqual(last_calls + [('update', 'ERROR        ', 1, None)], mypb.calls)
420
 
        last_calls = mypb.calls[:]
421
 
 
422
 
        # a failure
423
 
        result.startTest(dummy_test)
424
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 1, None)], mypb.calls)
425
 
        last_calls = mypb.calls[:]
426
 
        result.addFailure(dummy_test, dummy_error)
427
 
        self.assertEqual(last_calls + [('update', 'FAIL         ', 2, None)], mypb.calls)
428
 
        last_calls = mypb.calls[:]
429
 
 
430
 
        # a success
431
 
        result.startTest(dummy_test)
432
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 2, None)], mypb.calls)
433
 
        last_calls = mypb.calls[:]
434
 
        result.addSuccess(dummy_test)
435
 
        self.assertEqual(last_calls + [('update', 'OK           ', 3, None)], mypb.calls)
436
 
        last_calls = mypb.calls[:]
437
 
 
438
 
        # a skip
439
 
        result.startTest(dummy_test)
440
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 3, None)], mypb.calls)
441
 
        last_calls = mypb.calls[:]
442
 
        result.addSkipped(dummy_test, dummy_error)
443
 
        self.assertEqual(last_calls + [('update', 'SKIP         ', 4, None)], mypb.calls)
444
 
        last_calls = mypb.calls[:]
445
 
 
446
613
    def test_elapsed_time_with_benchmarking(self):
447
 
        result = bzrlib.tests._MyResult(self._log_file,
 
614
        result = bzrlib.tests.TextTestResult(self._log_file,
448
615
                                        descriptions=0,
449
616
                                        verbosity=1,
450
617
                                        )
453
620
        result.extractBenchmarkTime(self)
454
621
        timed_string = result._testTimeString()
455
622
        # without explicit benchmarking, we should get a simple time.
456
 
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
 
623
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
457
624
        # if a benchmark time is given, we want a x of y style result.
458
625
        self.time(time.sleep, 0.001)
459
626
        result.extractBenchmarkTime(self)
460
627
        timed_string = result._testTimeString()
461
 
        self.assertContainsRe(timed_string, "^   [ 1-9][0-9]ms/   [ 1-9][0-9]ms$")
 
628
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
462
629
        # extracting the time from a non-bzrlib testcase sets to None
463
630
        result._recordTestStartTime()
464
631
        result.extractBenchmarkTime(
465
632
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
466
633
        timed_string = result._testTimeString()
467
 
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
 
634
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
468
635
        # cheat. Yes, wash thy mouth out with soap.
469
636
        self._benchtime = None
470
637
 
 
638
    def test_assigned_benchmark_file_stores_date(self):
 
639
        output = StringIO()
 
640
        result = bzrlib.tests.TextTestResult(self._log_file,
 
641
                                        descriptions=0,
 
642
                                        verbosity=1,
 
643
                                        bench_history=output
 
644
                                        )
 
645
        output_string = output.getvalue()
 
646
        
 
647
        # if you are wondering about the regexp please read the comment in
 
648
        # test_bench_history (bzrlib.tests.test_selftest.TestRunner)
 
649
        # XXX: what comment?  -- Andrew Bennetts
 
650
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
651
 
 
652
    def test_benchhistory_records_test_times(self):
 
653
        result_stream = StringIO()
 
654
        result = bzrlib.tests.TextTestResult(
 
655
            self._log_file,
 
656
            descriptions=0,
 
657
            verbosity=1,
 
658
            bench_history=result_stream
 
659
            )
 
660
 
 
661
        # we want profile a call and check that its test duration is recorded
 
662
        # make a new test instance that when run will generate a benchmark
 
663
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
664
        # execute the test, which should succeed and record times
 
665
        example_test_case.run(result)
 
666
        lines = result_stream.getvalue().splitlines()
 
667
        self.assertEqual(2, len(lines))
 
668
        self.assertContainsRe(lines[1],
 
669
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
 
670
            "._time_hello_world_encoding")
 
671
 
471
672
    def _time_hello_world_encoding(self):
472
673
        """Profile two sleep calls
473
674
        
483
684
        except ImportError:
484
685
            raise TestSkipped("lsprof not installed.")
485
686
        result_stream = StringIO()
486
 
        result = bzrlib.tests._MyResult(
 
687
        result = bzrlib.tests.VerboseTestResult(
487
688
            unittest._WritelnDecorator(result_stream),
488
689
            descriptions=0,
489
690
            verbosity=2,
506
707
        #           1        0            ???         ???       ???(sleep) 
507
708
        # and then repeated but with 'world', rather than 'hello'.
508
709
        # this should appear in the output stream of our test result.
509
 
        self.assertContainsRe(result_stream.getvalue(), 
510
 
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)\n"
511
 
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n"
512
 
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?"
513
 
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n"
514
 
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n"
515
 
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?"
516
 
            )
 
710
        output = result_stream.getvalue()
 
711
        self.assertContainsRe(output,
 
712
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
 
713
        self.assertContainsRe(output,
 
714
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
 
715
        self.assertContainsRe(output,
 
716
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
717
        self.assertContainsRe(output,
 
718
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
 
719
 
 
720
    def test_known_failure(self):
 
721
        """A KnownFailure being raised should trigger several result actions."""
 
722
        class InstrumentedTestResult(ExtendedTestResult):
 
723
 
 
724
            def report_test_start(self, test): pass
 
725
            def report_known_failure(self, test, err):
 
726
                self._call = test, err
 
727
        result = InstrumentedTestResult(None, None, None, None)
 
728
        def test_function():
 
729
            raise KnownFailure('failed!')
 
730
        test = unittest.FunctionTestCase(test_function)
 
731
        test.run(result)
 
732
        # it should invoke 'report_known_failure'.
 
733
        self.assertEqual(2, len(result._call))
 
734
        self.assertEqual(test, result._call[0])
 
735
        self.assertEqual(KnownFailure, result._call[1][0])
 
736
        self.assertIsInstance(result._call[1][1], KnownFailure)
 
737
        # we dont introspec the traceback, if the rest is ok, it would be
 
738
        # exceptional for it not to be.
 
739
        # it should update the known_failure_count on the object.
 
740
        self.assertEqual(1, result.known_failure_count)
 
741
        # the result should be successful.
 
742
        self.assertTrue(result.wasSuccessful())
 
743
 
 
744
    def test_verbose_report_known_failure(self):
 
745
        # verbose test output formatting
 
746
        result_stream = StringIO()
 
747
        result = bzrlib.tests.VerboseTestResult(
 
748
            unittest._WritelnDecorator(result_stream),
 
749
            descriptions=0,
 
750
            verbosity=2,
 
751
            )
 
752
        test = self.get_passing_test()
 
753
        result.startTest(test)
 
754
        result.extractBenchmarkTime(test)
 
755
        prefix = len(result_stream.getvalue())
 
756
        # the err parameter has the shape:
 
757
        # (class, exception object, traceback)
 
758
        # KnownFailures dont get their tracebacks shown though, so we
 
759
        # can skip that.
 
760
        err = (KnownFailure, KnownFailure('foo'), None)
 
761
        result.report_known_failure(test, err)
 
762
        output = result_stream.getvalue()[prefix:]
 
763
        lines = output.splitlines()
 
764
        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
 
765
        self.assertEqual(lines[1], '    foo')
 
766
        self.assertEqual(2, len(lines))
 
767
 
 
768
    def test_text_report_known_failure(self):
 
769
        # text test output formatting
 
770
        pb = MockProgress()
 
771
        result = bzrlib.tests.TextTestResult(
 
772
            None,
 
773
            descriptions=0,
 
774
            verbosity=1,
 
775
            pb=pb,
 
776
            )
 
777
        test = self.get_passing_test()
 
778
        # this seeds the state to handle reporting the test.
 
779
        result.startTest(test)
 
780
        result.extractBenchmarkTime(test)
 
781
        # the err parameter has the shape:
 
782
        # (class, exception object, traceback)
 
783
        # KnownFailures dont get their tracebacks shown though, so we
 
784
        # can skip that.
 
785
        err = (KnownFailure, KnownFailure('foo'), None)
 
786
        result.report_known_failure(test, err)
 
787
        self.assertEqual(
 
788
            [
 
789
            ('update', '[1 in 0s] passing_test', None, None),
 
790
            ('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
 
791
            ],
 
792
            pb.calls)
 
793
        # known_failures should be printed in the summary, so if we run a test
 
794
        # after there are some known failures, the update prefix should match
 
795
        # this.
 
796
        result.known_failure_count = 3
 
797
        test.run(result)
 
798
        self.assertEqual(
 
799
            [
 
800
            ('update', '[2 in 0s, 3 known failures] passing_test', None, None),
 
801
            ],
 
802
            pb.calls[2:])
 
803
 
 
804
    def get_passing_test(self):
 
805
        """Return a test object that can't be run usefully."""
 
806
        def passing_test():
 
807
            pass
 
808
        return unittest.FunctionTestCase(passing_test)
 
809
 
 
810
    def test_add_not_supported(self):
 
811
        """Test the behaviour of invoking addNotSupported."""
 
812
        class InstrumentedTestResult(ExtendedTestResult):
 
813
            def report_test_start(self, test): pass
 
814
            def report_unsupported(self, test, feature):
 
815
                self._call = test, feature
 
816
        result = InstrumentedTestResult(None, None, None, None)
 
817
        test = SampleTestCase('_test_pass')
 
818
        feature = Feature()
 
819
        result.startTest(test)
 
820
        result.addNotSupported(test, feature)
 
821
        # it should invoke 'report_unsupported'.
 
822
        self.assertEqual(2, len(result._call))
 
823
        self.assertEqual(test, result._call[0])
 
824
        self.assertEqual(feature, result._call[1])
 
825
        # the result should be successful.
 
826
        self.assertTrue(result.wasSuccessful())
 
827
        # it should record the test against a count of tests not run due to
 
828
        # this feature.
 
829
        self.assertEqual(1, result.unsupported['Feature'])
 
830
        # and invoking it again should increment that counter
 
831
        result.addNotSupported(test, feature)
 
832
        self.assertEqual(2, result.unsupported['Feature'])
 
833
 
 
834
    def test_verbose_report_unsupported(self):
 
835
        # verbose test output formatting
 
836
        result_stream = StringIO()
 
837
        result = bzrlib.tests.VerboseTestResult(
 
838
            unittest._WritelnDecorator(result_stream),
 
839
            descriptions=0,
 
840
            verbosity=2,
 
841
            )
 
842
        test = self.get_passing_test()
 
843
        feature = Feature()
 
844
        result.startTest(test)
 
845
        result.extractBenchmarkTime(test)
 
846
        prefix = len(result_stream.getvalue())
 
847
        result.report_unsupported(test, feature)
 
848
        output = result_stream.getvalue()[prefix:]
 
849
        lines = output.splitlines()
 
850
        self.assertEqual(lines, ['NODEP                   0ms', "    The feature 'Feature' is not available."])
 
851
    
 
852
    def test_text_report_unsupported(self):
 
853
        # text test output formatting
 
854
        pb = MockProgress()
 
855
        result = bzrlib.tests.TextTestResult(
 
856
            None,
 
857
            descriptions=0,
 
858
            verbosity=1,
 
859
            pb=pb,
 
860
            )
 
861
        test = self.get_passing_test()
 
862
        feature = Feature()
 
863
        # this seeds the state to handle reporting the test.
 
864
        result.startTest(test)
 
865
        result.extractBenchmarkTime(test)
 
866
        result.report_unsupported(test, feature)
 
867
        # no output on unsupported features
 
868
        self.assertEqual(
 
869
            [('update', '[1 in 0s] passing_test', None, None)
 
870
            ],
 
871
            pb.calls)
 
872
        # the number of missing features should be printed in the progress
 
873
        # summary, so check for that.
 
874
        result.unsupported = {'foo':0, 'bar':0}
 
875
        test.run(result)
 
876
        self.assertEqual(
 
877
            [
 
878
            ('update', '[2 in 0s, 2 missing features] passing_test', None, None),
 
879
            ],
 
880
            pb.calls[1:])
 
881
    
 
882
    def test_unavailable_exception(self):
 
883
        """An UnavailableFeature being raised should invoke addNotSupported."""
 
884
        class InstrumentedTestResult(ExtendedTestResult):
 
885
 
 
886
            def report_test_start(self, test): pass
 
887
            def addNotSupported(self, test, feature):
 
888
                self._call = test, feature
 
889
        result = InstrumentedTestResult(None, None, None, None)
 
890
        feature = Feature()
 
891
        def test_function():
 
892
            raise UnavailableFeature(feature)
 
893
        test = unittest.FunctionTestCase(test_function)
 
894
        test.run(result)
 
895
        # it should invoke 'addNotSupported'.
 
896
        self.assertEqual(2, len(result._call))
 
897
        self.assertEqual(test, result._call[0])
 
898
        self.assertEqual(feature, result._call[1])
 
899
        # and not count as an error
 
900
        self.assertEqual(0, result.error_count)
517
901
 
518
902
 
519
903
class TestRunner(TestCase):
537
921
        finally:
538
922
            TestCaseInTempDir.TEST_ROOT = old_root
539
923
 
540
 
    def test_accepts_and_uses_pb_parameter(self):
541
 
        test = TestRunner('dummy_test')
542
 
        mypb = MockProgress()
543
 
        self.assertEqual([], mypb.calls)
544
 
        runner = TextTestRunner(stream=self._log_file, pb=mypb)
545
 
        result = self.run_test_runner(runner, test)
546
 
        self.assertEqual(1, result.testsRun)
547
 
        self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
548
 
        self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
549
 
        self.assertEqual(('update', 'OK           ', 1, None), mypb.calls[2])
550
 
        self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
551
 
        self.assertEqual(('clear',), mypb.calls[4])
552
 
        self.assertEqual(5, len(mypb.calls))
 
924
    def test_known_failure_failed_run(self):
 
925
        # run a test that generates a known failure which should be printed in
 
926
        # the final output when real failures occur.
 
927
        def known_failure_test():
 
928
            raise KnownFailure('failed')
 
929
        test = unittest.TestSuite()
 
930
        test.addTest(unittest.FunctionTestCase(known_failure_test))
 
931
        def failing_test():
 
932
            raise AssertionError('foo')
 
933
        test.addTest(unittest.FunctionTestCase(failing_test))
 
934
        stream = StringIO()
 
935
        runner = TextTestRunner(stream=stream)
 
936
        result = self.run_test_runner(runner, test)
 
937
        lines = stream.getvalue().splitlines()
 
938
        self.assertEqual([
 
939
            '',
 
940
            '======================================================================',
 
941
            'FAIL: unittest.FunctionTestCase (failing_test)',
 
942
            '----------------------------------------------------------------------',
 
943
            'Traceback (most recent call last):',
 
944
            '    raise AssertionError(\'foo\')',
 
945
            'AssertionError: foo',
 
946
            '',
 
947
            '----------------------------------------------------------------------',
 
948
            '',
 
949
            'FAILED (failures=1, known_failure_count=1)'],
 
950
            lines[0:5] + lines[6:10] + lines[11:])
 
951
 
 
952
    def test_known_failure_ok_run(self):
 
953
        # run a test that generates a known failure which should be printed in the final output.
 
954
        def known_failure_test():
 
955
            raise KnownFailure('failed')
 
956
        test = unittest.FunctionTestCase(known_failure_test)
 
957
        stream = StringIO()
 
958
        runner = TextTestRunner(stream=stream)
 
959
        result = self.run_test_runner(runner, test)
 
960
        self.assertContainsRe(stream.getvalue(),
 
961
            '\n'
 
962
            '-*\n'
 
963
            'Ran 1 test in .*\n'
 
964
            '\n'
 
965
            'OK \\(known_failures=1\\)\n')
553
966
 
554
967
    def test_skipped_test(self):
555
968
        # run a test that is skipped, and check the suite as a whole still
557
970
        # skipping_test must be hidden in here so it's not run as a real test
558
971
        def skipping_test():
559
972
            raise TestSkipped('test intentionally skipped')
 
973
 
560
974
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
561
975
        test = unittest.FunctionTestCase(skipping_test)
562
976
        result = self.run_test_runner(runner, test)
563
977
        self.assertTrue(result.wasSuccessful())
564
978
 
 
979
    def test_skipped_from_setup(self):
 
980
        class SkippedSetupTest(TestCase):
 
981
 
 
982
            def setUp(self):
 
983
                self.counter = 1
 
984
                self.addCleanup(self.cleanup)
 
985
                raise TestSkipped('skipped setup')
 
986
 
 
987
            def test_skip(self):
 
988
                self.fail('test reached')
 
989
 
 
990
            def cleanup(self):
 
991
                self.counter -= 1
 
992
 
 
993
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
994
        test = SkippedSetupTest('test_skip')
 
995
        result = self.run_test_runner(runner, test)
 
996
        self.assertTrue(result.wasSuccessful())
 
997
        # Check if cleanup was called the right number of times.
 
998
        self.assertEqual(0, test.counter)
 
999
 
 
1000
    def test_skipped_from_test(self):
 
1001
        class SkippedTest(TestCase):
 
1002
 
 
1003
            def setUp(self):
 
1004
                self.counter = 1
 
1005
                self.addCleanup(self.cleanup)
 
1006
 
 
1007
            def test_skip(self):
 
1008
                raise TestSkipped('skipped test')
 
1009
 
 
1010
            def cleanup(self):
 
1011
                self.counter -= 1
 
1012
 
 
1013
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
1014
        test = SkippedTest('test_skip')
 
1015
        result = self.run_test_runner(runner, test)
 
1016
        self.assertTrue(result.wasSuccessful())
 
1017
        # Check if cleanup was called the right number of times.
 
1018
        self.assertEqual(0, test.counter)
 
1019
 
 
1020
    def test_unsupported_features_listed(self):
 
1021
        """When unsupported features are encountered they are detailed."""
 
1022
        class Feature1(Feature):
 
1023
            def _probe(self): return False
 
1024
        class Feature2(Feature):
 
1025
            def _probe(self): return False
 
1026
        # create sample tests
 
1027
        test1 = SampleTestCase('_test_pass')
 
1028
        test1._test_needs_features = [Feature1()]
 
1029
        test2 = SampleTestCase('_test_pass')
 
1030
        test2._test_needs_features = [Feature2()]
 
1031
        test = unittest.TestSuite()
 
1032
        test.addTest(test1)
 
1033
        test.addTest(test2)
 
1034
        stream = StringIO()
 
1035
        runner = TextTestRunner(stream=stream)
 
1036
        result = self.run_test_runner(runner, test)
 
1037
        lines = stream.getvalue().splitlines()
 
1038
        self.assertEqual([
 
1039
            'OK',
 
1040
            "Missing feature 'Feature1' skipped 1 tests.",
 
1041
            "Missing feature 'Feature2' skipped 1 tests.",
 
1042
            ],
 
1043
            lines[-3:])
 
1044
 
 
1045
    def test_bench_history(self):
 
1046
        # tests that the running the benchmark produces a history file
 
1047
        # containing a timestamp and the revision id of the bzrlib source which
 
1048
        # was tested.
 
1049
        workingtree = _get_bzr_source_tree()
 
1050
        test = TestRunner('dummy_test')
 
1051
        output = StringIO()
 
1052
        runner = TextTestRunner(stream=self._log_file, bench_history=output)
 
1053
        result = self.run_test_runner(runner, test)
 
1054
        output_string = output.getvalue()
 
1055
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
1056
        if workingtree is not None:
 
1057
            revision_id = workingtree.get_parent_ids()[0]
 
1058
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
1059
 
 
1060
    def test_success_log_deleted(self):
 
1061
        """Successful tests have their log deleted"""
 
1062
 
 
1063
        class LogTester(TestCase):
 
1064
 
 
1065
            def test_success(self):
 
1066
                self.log('this will be removed\n')
 
1067
 
 
1068
        sio = cStringIO.StringIO()
 
1069
        runner = TextTestRunner(stream=sio)
 
1070
        test = LogTester('test_success')
 
1071
        result = self.run_test_runner(runner, test)
 
1072
 
 
1073
        log = test._get_log()
 
1074
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1075
        self.assertEqual('', test._log_contents)
 
1076
        self.assertIs(None, test._log_file_name)
 
1077
 
 
1078
    def test_fail_log_kept(self):
 
1079
        """Failed tests have their log kept"""
 
1080
 
 
1081
        class LogTester(TestCase):
 
1082
 
 
1083
            def test_fail(self):
 
1084
                self.log('this will be kept\n')
 
1085
                self.fail('this test fails')
 
1086
 
 
1087
        sio = cStringIO.StringIO()
 
1088
        runner = TextTestRunner(stream=sio)
 
1089
        test = LogTester('test_fail')
 
1090
        result = self.run_test_runner(runner, test)
 
1091
 
 
1092
        text = sio.getvalue()
 
1093
        self.assertContainsRe(text, 'this will be kept')
 
1094
        self.assertContainsRe(text, 'this test fails')
 
1095
 
 
1096
        log = test._get_log()
 
1097
        self.assertContainsRe(log, 'this will be kept')
 
1098
        self.assertEqual(log, test._log_contents)
 
1099
 
 
1100
    def test_error_log_kept(self):
 
1101
        """Tests with errors have their log kept"""
 
1102
 
 
1103
        class LogTester(TestCase):
 
1104
 
 
1105
            def test_error(self):
 
1106
                self.log('this will be kept\n')
 
1107
                raise ValueError('random exception raised')
 
1108
 
 
1109
        sio = cStringIO.StringIO()
 
1110
        runner = TextTestRunner(stream=sio)
 
1111
        test = LogTester('test_error')
 
1112
        result = self.run_test_runner(runner, test)
 
1113
 
 
1114
        text = sio.getvalue()
 
1115
        self.assertContainsRe(text, 'this will be kept')
 
1116
        self.assertContainsRe(text, 'random exception raised')
 
1117
 
 
1118
        log = test._get_log()
 
1119
        self.assertContainsRe(log, 'this will be kept')
 
1120
        self.assertEqual(log, test._log_contents)
 
1121
 
 
1122
 
 
1123
class SampleTestCase(TestCase):
 
1124
 
 
1125
    def _test_pass(self):
 
1126
        pass
 
1127
 
565
1128
 
566
1129
class TestTestCase(TestCase):
567
1130
    """Tests that test the core bzrlib TestCase."""
574
1137
        # the outer child test
575
1138
        note("outer_start")
576
1139
        self.inner_test = TestTestCase("inner_child")
577
 
        result = bzrlib.tests._MyResult(self._log_file,
 
1140
        result = bzrlib.tests.TextTestResult(self._log_file,
578
1141
                                        descriptions=0,
579
1142
                                        verbosity=1)
580
1143
        self.inner_test.run(result)
594
1157
        # the outer child test
595
1158
        original_trace = bzrlib.trace._trace_file
596
1159
        outer_test = TestTestCase("outer_child")
597
 
        result = bzrlib.tests._MyResult(self._log_file,
 
1160
        result = bzrlib.tests.TextTestResult(self._log_file,
598
1161
                                        descriptions=0,
599
1162
                                        verbosity=1)
600
1163
        outer_test.run(result)
609
1172
        """Test that the TestCase.time() method accumulates a benchmark time."""
610
1173
        sample_test = TestTestCase("method_that_times_a_bit_twice")
611
1174
        output_stream = StringIO()
612
 
        result = bzrlib.tests._MyResult(
 
1175
        result = bzrlib.tests.VerboseTestResult(
613
1176
            unittest._WritelnDecorator(output_stream),
614
1177
            descriptions=0,
615
 
            verbosity=2)
 
1178
            verbosity=2,
 
1179
            num_tests=sample_test.countTestCases())
616
1180
        sample_test.run(result)
617
1181
        self.assertContainsRe(
618
1182
            output_stream.getvalue(),
619
 
            "[1-9][0-9]ms/   [1-9][0-9]ms\n$")
620
 
        
 
1183
            r"\d+ms/ +\d+ms\n$")
 
1184
 
 
1185
    def test_hooks_sanitised(self):
 
1186
        """The bzrlib hooks should be sanitised by setUp."""
 
1187
        self.assertEqual(bzrlib.branch.BranchHooks(),
 
1188
            bzrlib.branch.Branch.hooks)
 
1189
        self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
 
1190
            bzrlib.smart.server.SmartTCPServer.hooks)
 
1191
 
621
1192
    def test__gather_lsprof_in_benchmarks(self):
622
1193
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
623
1194
        
638
1209
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
639
1210
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
640
1211
 
 
1212
    def test_knownFailure(self):
 
1213
        """Self.knownFailure() should raise a KnownFailure exception."""
 
1214
        self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
 
1215
 
 
1216
    def test_requireFeature_available(self):
 
1217
        """self.requireFeature(available) is a no-op."""
 
1218
        class Available(Feature):
 
1219
            def _probe(self):return True
 
1220
        feature = Available()
 
1221
        self.requireFeature(feature)
 
1222
 
 
1223
    def test_requireFeature_unavailable(self):
 
1224
        """self.requireFeature(unavailable) raises UnavailableFeature."""
 
1225
        class Unavailable(Feature):
 
1226
            def _probe(self):return False
 
1227
        feature = Unavailable()
 
1228
        self.assertRaises(UnavailableFeature, self.requireFeature, feature)
 
1229
 
 
1230
    def test_run_no_parameters(self):
 
1231
        test = SampleTestCase('_test_pass')
 
1232
        test.run()
 
1233
    
 
1234
    def test_run_enabled_unittest_result(self):
 
1235
        """Test we revert to regular behaviour when the test is enabled."""
 
1236
        test = SampleTestCase('_test_pass')
 
1237
        class EnabledFeature(object):
 
1238
            def available(self):
 
1239
                return True
 
1240
        test._test_needs_features = [EnabledFeature()]
 
1241
        result = unittest.TestResult()
 
1242
        test.run(result)
 
1243
        self.assertEqual(1, result.testsRun)
 
1244
        self.assertEqual([], result.errors)
 
1245
        self.assertEqual([], result.failures)
 
1246
 
 
1247
    def test_run_disabled_unittest_result(self):
 
1248
        """Test our compatability for disabled tests with unittest results."""
 
1249
        test = SampleTestCase('_test_pass')
 
1250
        class DisabledFeature(object):
 
1251
            def available(self):
 
1252
                return False
 
1253
        test._test_needs_features = [DisabledFeature()]
 
1254
        result = unittest.TestResult()
 
1255
        test.run(result)
 
1256
        self.assertEqual(1, result.testsRun)
 
1257
        self.assertEqual([], result.errors)
 
1258
        self.assertEqual([], result.failures)
 
1259
 
 
1260
    def test_run_disabled_supporting_result(self):
 
1261
        """Test disabled tests behaviour with support aware results."""
 
1262
        test = SampleTestCase('_test_pass')
 
1263
        class DisabledFeature(object):
 
1264
            def available(self):
 
1265
                return False
 
1266
        the_feature = DisabledFeature()
 
1267
        test._test_needs_features = [the_feature]
 
1268
        class InstrumentedTestResult(unittest.TestResult):
 
1269
            def __init__(self):
 
1270
                unittest.TestResult.__init__(self)
 
1271
                self.calls = []
 
1272
            def startTest(self, test):
 
1273
                self.calls.append(('startTest', test))
 
1274
            def stopTest(self, test):
 
1275
                self.calls.append(('stopTest', test))
 
1276
            def addNotSupported(self, test, feature):
 
1277
                self.calls.append(('addNotSupported', test, feature))
 
1278
        result = InstrumentedTestResult()
 
1279
        test.run(result)
 
1280
        self.assertEqual([
 
1281
            ('startTest', test),
 
1282
            ('addNotSupported', test, the_feature),
 
1283
            ('stopTest', test),
 
1284
            ],
 
1285
            result.calls)
 
1286
 
 
1287
 
 
1288
@symbol_versioning.deprecated_function(zero_eleven)
 
1289
def sample_deprecated_function():
 
1290
    """A deprecated function to test applyDeprecated with."""
 
1291
    return 2
 
1292
 
 
1293
 
 
1294
def sample_undeprecated_function(a_param):
 
1295
    """A undeprecated function to test applyDeprecated with."""
 
1296
 
 
1297
 
 
1298
class ApplyDeprecatedHelper(object):
 
1299
    """A helper class for ApplyDeprecated tests."""
 
1300
 
 
1301
    @symbol_versioning.deprecated_method(zero_eleven)
 
1302
    def sample_deprecated_method(self, param_one):
 
1303
        """A deprecated method for testing with."""
 
1304
        return param_one
 
1305
 
 
1306
    def sample_normal_method(self):
 
1307
        """A undeprecated method."""
 
1308
 
 
1309
    @symbol_versioning.deprecated_method(zero_ten)
 
1310
    def sample_nested_deprecation(self):
 
1311
        return sample_deprecated_function()
 
1312
 
641
1313
 
642
1314
class TestExtraAssertions(TestCase):
643
1315
    """Tests for new test assertions in bzrlib test suite"""
652
1324
        self.assertEndsWith('foo', 'oo')
653
1325
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
654
1326
 
 
1327
    def test_applyDeprecated_not_deprecated(self):
 
1328
        sample_object = ApplyDeprecatedHelper()
 
1329
        # calling an undeprecated callable raises an assertion
 
1330
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
1331
            sample_object.sample_normal_method)
 
1332
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
1333
            sample_undeprecated_function, "a param value")
 
1334
        # calling a deprecated callable (function or method) with the wrong
 
1335
        # expected deprecation fails.
 
1336
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
1337
            sample_object.sample_deprecated_method, "a param value")
 
1338
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
1339
            sample_deprecated_function)
 
1340
        # calling a deprecated callable (function or method) with the right
 
1341
        # expected deprecation returns the functions result.
 
1342
        self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
 
1343
            sample_object.sample_deprecated_method, "a param value"))
 
1344
        self.assertEqual(2, self.applyDeprecated(zero_eleven,
 
1345
            sample_deprecated_function))
 
1346
        # calling a nested deprecation with the wrong deprecation version
 
1347
        # fails even if a deeper nested function was deprecated with the 
 
1348
        # supplied version.
 
1349
        self.assertRaises(AssertionError, self.applyDeprecated,
 
1350
            zero_eleven, sample_object.sample_nested_deprecation)
 
1351
        # calling a nested deprecation with the right deprecation value
 
1352
        # returns the calls result.
 
1353
        self.assertEqual(2, self.applyDeprecated(zero_ten,
 
1354
            sample_object.sample_nested_deprecation))
 
1355
 
 
1356
    def test_callDeprecated(self):
 
1357
        def testfunc(be_deprecated, result=None):
 
1358
            if be_deprecated is True:
 
1359
                symbol_versioning.warn('i am deprecated', DeprecationWarning, 
 
1360
                                       stacklevel=1)
 
1361
            return result
 
1362
        result = self.callDeprecated(['i am deprecated'], testfunc, True)
 
1363
        self.assertIs(None, result)
 
1364
        result = self.callDeprecated([], testfunc, False, 'result')
 
1365
        self.assertEqual('result', result)
 
1366
        self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
 
1367
        self.callDeprecated([], testfunc, be_deprecated=False)
 
1368
 
655
1369
 
656
1370
class TestConvenienceMakers(TestCaseWithTransport):
657
1371
    """Test for the make_* convenience functions."""
665
1379
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
666
1380
                              bzrlib.bzrdir.BzrDirFormat6)
667
1381
 
 
1382
    def test_make_branch_and_memory_tree(self):
 
1383
        # we should be able to get a new branch and a mutable tree from
 
1384
        # TestCaseWithTransport
 
1385
        tree = self.make_branch_and_memory_tree('a')
 
1386
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
 
1387
 
 
1388
 
 
1389
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
 
1390
 
 
1391
    def test_make_tree_for_sftp_branch(self):
 
1392
        """Transports backed by local directories create local trees."""
 
1393
 
 
1394
        tree = self.make_branch_and_tree('t1')
 
1395
        base = tree.bzrdir.root_transport.base
 
1396
        self.failIf(base.startswith('sftp'),
 
1397
                'base %r is on sftp but should be local' % base)
 
1398
        self.assertEquals(tree.bzrdir.root_transport,
 
1399
                tree.branch.bzrdir.root_transport)
 
1400
        self.assertEquals(tree.bzrdir.root_transport,
 
1401
                tree.branch.repository.bzrdir.root_transport)
 
1402
 
668
1403
 
669
1404
class TestSelftest(TestCase):
670
1405
    """Tests of bzrlib.tests.selftest."""
680
1415
            test_suite_factory=factory)
681
1416
        self.assertEqual([True], factory_called)
682
1417
 
683
 
    def test_run_bzr_subprocess(self):
684
 
        """The run_bzr_helper_external comand behaves nicely."""
685
 
        result = self.run_bzr_subprocess('--version')
686
 
        result = self.run_bzr_subprocess('--version', retcode=None)
687
 
        self.assertContainsRe(result[0], 'is free software')
688
 
        self.assertRaises(AssertionError, self.run_bzr_subprocess, 
689
 
                          '--versionn')
690
 
        result = self.run_bzr_subprocess('--versionn', retcode=3)
691
 
        result = self.run_bzr_subprocess('--versionn', retcode=None)
692
 
        self.assertContainsRe(result[1], 'unknown command')
693
 
        err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge', 
694
 
                                      retcode=3)[1]
695
 
        self.assertContainsRe(err, 'No known merge type magic merge')
 
1418
 
 
1419
class TestSelftestCleanOutput(TestCaseInTempDir):
 
1420
 
 
1421
    def test_clean_output(self):
 
1422
        # test functionality of clean_selftest_output()
 
1423
        self.build_tree(['test0000.tmp/', 'test0001.tmp/',
 
1424
                         'bzrlib/', 'tests/',
 
1425
                         'bzr', 'setup.py', 'test9999.tmp'])
 
1426
 
 
1427
        root = os.getcwdu()
 
1428
        before = os.listdir(root)
 
1429
        before.sort()
 
1430
        self.assertEquals(['bzr','bzrlib','setup.py',
 
1431
                           'test0000.tmp','test0001.tmp',
 
1432
                           'test9999.tmp','tests'],
 
1433
                           before)
 
1434
        clean_selftest_output(root, quiet=True)
 
1435
        after = os.listdir(root)
 
1436
        after.sort()
 
1437
        self.assertEquals(['bzr','bzrlib','setup.py',
 
1438
                           'test9999.tmp','tests'],
 
1439
                           after)
 
1440
 
 
1441
    def test_clean_readonly(self):
 
1442
        # test for delete read-only files
 
1443
        self.build_tree(['test0000.tmp/', 'test0000.tmp/foo'])
 
1444
        osutils.make_readonly('test0000.tmp/foo')
 
1445
        root = os.getcwdu()
 
1446
        before = os.listdir(root);  before.sort()
 
1447
        self.assertEquals(['test0000.tmp'], before)
 
1448
        clean_selftest_output(root, quiet=True)
 
1449
        after = os.listdir(root);   after.sort()
 
1450
        self.assertEquals([], after)
 
1451
 
 
1452
 
 
1453
class TestKnownFailure(TestCase):
 
1454
 
 
1455
    def test_known_failure(self):
 
1456
        """Check that KnownFailure is defined appropriately."""
 
1457
        # a KnownFailure is an assertion error for compatability with unaware
 
1458
        # runners.
 
1459
        self.assertIsInstance(KnownFailure(""), AssertionError)
 
1460
 
 
1461
    def test_expect_failure(self):
 
1462
        try:
 
1463
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
1464
        except KnownFailure, e:
 
1465
            self.assertEqual('Doomed to failure', e.args[0])
 
1466
        try:
 
1467
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
1468
        except AssertionError, e:
 
1469
            self.assertEqual('Unexpected success.  Should have failed:'
 
1470
                             ' Doomed to failure', e.args[0])
 
1471
        else:
 
1472
            self.fail('Assertion not raised')
 
1473
 
 
1474
 
 
1475
class TestFeature(TestCase):
 
1476
 
 
1477
    def test_caching(self):
 
1478
        """Feature._probe is called by the feature at most once."""
 
1479
        class InstrumentedFeature(Feature):
 
1480
            def __init__(self):
 
1481
                Feature.__init__(self)
 
1482
                self.calls = []
 
1483
            def _probe(self):
 
1484
                self.calls.append('_probe')
 
1485
                return False
 
1486
        feature = InstrumentedFeature()
 
1487
        feature.available()
 
1488
        self.assertEqual(['_probe'], feature.calls)
 
1489
        feature.available()
 
1490
        self.assertEqual(['_probe'], feature.calls)
 
1491
 
 
1492
    def test_named_str(self):
 
1493
        """Feature.__str__ should thunk to feature_name()."""
 
1494
        class NamedFeature(Feature):
 
1495
            def feature_name(self):
 
1496
                return 'symlinks'
 
1497
        feature = NamedFeature()
 
1498
        self.assertEqual('symlinks', str(feature))
 
1499
 
 
1500
    def test_default_str(self):
 
1501
        """Feature.__str__ should default to __class__.__name__."""
 
1502
        class NamedFeature(Feature):
 
1503
            pass
 
1504
        feature = NamedFeature()
 
1505
        self.assertEqual('NamedFeature', str(feature))
 
1506
 
 
1507
 
 
1508
class TestUnavailableFeature(TestCase):
 
1509
 
 
1510
    def test_access_feature(self):
 
1511
        feature = Feature()
 
1512
        exception = UnavailableFeature(feature)
 
1513
        self.assertIs(feature, exception.args[0])
 
1514
 
 
1515
 
 
1516
class TestSelftestFiltering(TestCase):
 
1517
 
 
1518
    def setUp(self):
 
1519
        self.suite = TestUtil.TestSuite()
 
1520
        self.loader = TestUtil.TestLoader()
 
1521
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
 
1522
            'bzrlib.tests.test_selftest']))
 
1523
        self.all_names = [t.id() for t in iter_suite_tests(self.suite)]
 
1524
 
 
1525
    def test_filter_suite_by_re(self):
 
1526
        filtered_suite = filter_suite_by_re(self.suite, 'test_filter')
 
1527
        filtered_names = [t.id() for t in iter_suite_tests(filtered_suite)]
 
1528
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
 
1529
            'TestSelftestFiltering.test_filter_suite_by_re'])
 
1530
            
 
1531
    def test_sort_suite_by_re(self):
 
1532
        sorted_suite = sort_suite_by_re(self.suite, 'test_filter')
 
1533
        sorted_names = [t.id() for t in iter_suite_tests(sorted_suite)]
 
1534
        self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
 
1535
            'TestSelftestFiltering.test_filter_suite_by_re')
 
1536
        self.assertEquals(sorted(self.all_names), sorted(sorted_names))
 
1537