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

  • Committer: Martin Pool
  • Date: 2006-10-06 02:04:17 UTC
  • mfrom: (1908.10.1 bench_usecases.merge2)
  • mto: This revision was merged to the branch mainline in revision 2068.
  • Revision ID: mbp@sourcefrog.net-20061006020417-4949ca86f4417a4d
merge additional fix from cfbolz

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
13
13
# along with this program; if not, write to the Free Software
14
14
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15
15
 
16
 
"""Tests for the test framework
17
 
"""
 
16
"""Tests for the test framework."""
18
17
 
 
18
import cStringIO
19
19
import os
 
20
from StringIO import StringIO
20
21
import sys
 
22
import time
21
23
import unittest
22
24
import warnings
23
25
 
 
26
from bzrlib import osutils
24
27
import bzrlib
 
28
from bzrlib.progress import _BaseProgressBar
25
29
from bzrlib.tests import (
26
 
                          _load_module_by_name,
27
30
                          ChrootedTestCase,
28
31
                          TestCase,
29
32
                          TestCaseInTempDir,
30
33
                          TestCaseWithTransport,
31
34
                          TestSkipped,
 
35
                          TestSuite,
32
36
                          TextTestRunner,
33
37
                          )
 
38
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
 
39
from bzrlib.tests.TestUtil import _load_module_by_name
34
40
import bzrlib.errors as errors
 
41
from bzrlib import symbol_versioning
 
42
from bzrlib.symbol_versioning import zero_ten, zero_eleven
 
43
from bzrlib.trace import note
 
44
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
45
from bzrlib.version import _get_bzr_source_tree
35
46
 
36
47
 
37
48
class SelftestTests(TestCase):
52
63
        """Test logs are captured when a test fails."""
53
64
        self.log('a test message')
54
65
        self._log_file.flush()
55
 
        self.assertContainsRe(self._get_log(), 'a test message\n')
 
66
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
67
                              'a test message\n')
56
68
 
57
69
 
58
70
class TestTreeShape(TestCaseInTempDir):
67
79
        self.failUnlessExists(filename)
68
80
 
69
81
 
70
 
class TestSkippedTest(TestCase):
71
 
    """Try running a test which is skipped, make sure it's reported properly."""
72
 
 
73
 
    def test_skipped_test(self):
74
 
        # must be hidden in here so it's not run as a real test
75
 
        def skipping_test():
76
 
            raise TestSkipped('test intentionally skipped')
77
 
        runner = TextTestRunner(stream=self._log_file)
78
 
        test = unittest.FunctionTestCase(skipping_test)
79
 
        result = runner.run(test)
80
 
        self.assertTrue(result.wasSuccessful())
81
 
 
82
 
 
83
82
class TestTransportProviderAdapter(TestCase):
84
83
    """A group of tests that test the transport implementation adaption core.
85
84
 
332
331
        self.assertEqual(tests[1].transport_readonly_server, server2)
333
332
 
334
333
 
 
334
class TestTreeProviderAdapter(TestCase):
 
335
    """Test the setup of tree_implementation tests."""
 
336
 
 
337
    def test_adapted_tests(self):
 
338
        # the tree implementation adapter is meant to setup one instance for
 
339
        # each working tree format, and one additional instance that will
 
340
        # use the default wt format, but create a revision tree for the tests.
 
341
        # this means that the wt ones should have the workingtree_to_test_tree
 
342
        # attribute set to 'return_parameter' and the revision one set to
 
343
        # revision_tree_from_workingtree.
 
344
 
 
345
        from bzrlib.tests.tree_implementations import (
 
346
            TreeTestProviderAdapter,
 
347
            return_parameter,
 
348
            revision_tree_from_workingtree
 
349
            )
 
350
        from bzrlib.workingtree import WorkingTreeFormat
 
351
        input_test = TestTreeProviderAdapter(
 
352
            "test_adapted_tests")
 
353
        server1 = "a"
 
354
        server2 = "b"
 
355
        formats = [("c", "C"), ("d", "D")]
 
356
        adapter = TreeTestProviderAdapter(server1, server2, formats)
 
357
        suite = adapter.adapt(input_test)
 
358
        tests = list(iter(suite))
 
359
        self.assertEqual(3, len(tests))
 
360
        default_format = WorkingTreeFormat.get_default_format()
 
361
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
362
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
363
        self.assertEqual(tests[0].transport_server, server1)
 
364
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
365
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
366
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
367
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
368
        self.assertEqual(tests[1].transport_server, server1)
 
369
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
370
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
371
        self.assertEqual(tests[2].workingtree_format, default_format)
 
372
        self.assertEqual(tests[2].bzrdir_format, default_format._matchingbzrdir)
 
373
        self.assertEqual(tests[2].transport_server, server1)
 
374
        self.assertEqual(tests[2].transport_readonly_server, server2)
 
375
        self.assertEqual(tests[2].workingtree_to_test_tree,
 
376
            revision_tree_from_workingtree)
 
377
 
 
378
 
 
379
class TestInterTreeProviderAdapter(TestCase):
 
380
    """A group of tests that test the InterTreeTestAdapter."""
 
381
 
 
382
    def test_adapted_tests(self):
 
383
        # check that constructor parameters are passed through to the adapted
 
384
        # test.
 
385
        # for InterTree tests we want the machinery to bring up two trees in
 
386
        # each instance: the base one, and the one we are interacting with.
 
387
        # because each optimiser can be direction specific, we need to test
 
388
        # each optimiser in its chosen direction.
 
389
        # unlike the TestProviderAdapter we dont want to automatically add a
 
390
        # parameterised one for WorkingTree - the optimisers will tell us what
 
391
        # ones to add.
 
392
        from bzrlib.tests.tree_implementations import (
 
393
            return_parameter,
 
394
            revision_tree_from_workingtree
 
395
            )
 
396
        from bzrlib.tests.intertree_implementations import (
 
397
            InterTreeTestProviderAdapter,
 
398
            )
 
399
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
 
400
        input_test = TestInterTreeProviderAdapter(
 
401
            "test_adapted_tests")
 
402
        server1 = "a"
 
403
        server2 = "b"
 
404
        format1 = WorkingTreeFormat2()
 
405
        format2 = WorkingTreeFormat3()
 
406
        formats = [(str, format1, format2, False, True),
 
407
            (int, format2, format1, False, True)]
 
408
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
 
409
        suite = adapter.adapt(input_test)
 
410
        tests = list(iter(suite))
 
411
        self.assertEqual(2, len(tests))
 
412
        self.assertEqual(tests[0].intertree_class, formats[0][0])
 
413
        self.assertEqual(tests[0].workingtree_format, formats[0][1])
 
414
        self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
 
415
        self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
 
416
        self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
 
417
        self.assertEqual(tests[0].transport_server, server1)
 
418
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
419
        self.assertEqual(tests[1].intertree_class, formats[1][0])
 
420
        self.assertEqual(tests[1].workingtree_format, formats[1][1])
 
421
        self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
 
422
        self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
 
423
        self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
 
424
        self.assertEqual(tests[1].transport_server, server1)
 
425
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
426
 
 
427
 
 
428
class TestTestCaseInTempDir(TestCaseInTempDir):
 
429
 
 
430
    def test_home_is_not_working(self):
 
431
        self.assertNotEqual(self.test_dir, self.test_home_dir)
 
432
        cwd = osutils.getcwd()
 
433
        self.assertEqual(self.test_dir, cwd)
 
434
        self.assertEqual(self.test_home_dir, os.environ['HOME'])
 
435
 
 
436
 
335
437
class TestTestCaseWithTransport(TestCaseWithTransport):
336
438
    """Tests for the convenience functions TestCaseWithTransport introduces."""
337
439
 
375
477
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
376
478
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
377
479
 
 
480
 
 
481
class TestTestCaseTransports(TestCaseWithTransport):
 
482
 
 
483
    def setUp(self):
 
484
        super(TestTestCaseTransports, self).setUp()
 
485
        self.transport_server = MemoryServer
 
486
 
 
487
    def test_make_bzrdir_preserves_transport(self):
 
488
        t = self.get_transport()
 
489
        result_bzrdir = self.make_bzrdir('subdir')
 
490
        self.assertIsInstance(result_bzrdir.transport, 
 
491
                              MemoryTransport)
 
492
        # should not be on disk, should only be in memory
 
493
        self.failIfExists('subdir')
 
494
 
 
495
 
378
496
class TestChrootedTest(ChrootedTestCase):
379
497
 
380
498
    def test_root_is_root(self):
384
502
        self.assertEqual(url, t.clone('..').base)
385
503
 
386
504
 
 
505
class MockProgress(_BaseProgressBar):
 
506
    """Progress-bar standin that records calls.
 
507
 
 
508
    Useful for testing pb using code.
 
509
    """
 
510
 
 
511
    def __init__(self):
 
512
        _BaseProgressBar.__init__(self)
 
513
        self.calls = []
 
514
 
 
515
    def tick(self):
 
516
        self.calls.append(('tick',))
 
517
 
 
518
    def update(self, msg=None, current=None, total=None):
 
519
        self.calls.append(('update', msg, current, total))
 
520
 
 
521
    def clear(self):
 
522
        self.calls.append(('clear',))
 
523
 
 
524
    def note(self, msg, *args):
 
525
        self.calls.append(('note', msg, args))
 
526
 
 
527
 
 
528
class TestTestResult(TestCase):
 
529
 
 
530
    def test_progress_bar_style_quiet(self):
 
531
        # test using a progress bar.
 
532
        dummy_test = TestTestResult('test_progress_bar_style_quiet')
 
533
        dummy_error = (Exception, None, [])
 
534
        mypb = MockProgress()
 
535
        mypb.update('Running tests', 0, 4)
 
536
        last_calls = mypb.calls[:]
 
537
 
 
538
        result = bzrlib.tests._MyResult(self._log_file,
 
539
                                        descriptions=0,
 
540
                                        verbosity=1,
 
541
                                        pb=mypb)
 
542
        self.assertEqual(last_calls, mypb.calls)
 
543
 
 
544
        def shorten(s):
 
545
            """Shorten a string based on the terminal width"""
 
546
            return result._ellipsise_unimportant_words(s,
 
547
                                 osutils.terminal_width())
 
548
 
 
549
        # an error 
 
550
        result.startTest(dummy_test)
 
551
        # starting a test prints the test name
 
552
        last_calls += [('update', '...tyle_quiet', 0, None)]
 
553
        self.assertEqual(last_calls, mypb.calls)
 
554
        result.addError(dummy_test, dummy_error)
 
555
        last_calls += [('update', 'ERROR        ', 1, None),
 
556
                       ('note', shorten(dummy_test.id() + ': ERROR'), ())
 
557
                      ]
 
558
        self.assertEqual(last_calls, mypb.calls)
 
559
 
 
560
        # a failure
 
561
        result.startTest(dummy_test)
 
562
        last_calls += [('update', '...tyle_quiet', 1, None)]
 
563
        self.assertEqual(last_calls, mypb.calls)
 
564
        last_calls += [('update', 'FAIL         ', 2, None),
 
565
                       ('note', shorten(dummy_test.id() + ': FAIL'), ())
 
566
                      ]
 
567
        result.addFailure(dummy_test, dummy_error)
 
568
        self.assertEqual(last_calls, mypb.calls)
 
569
 
 
570
        # a success
 
571
        result.startTest(dummy_test)
 
572
        last_calls += [('update', '...tyle_quiet', 2, None)]
 
573
        self.assertEqual(last_calls, mypb.calls)
 
574
        result.addSuccess(dummy_test)
 
575
        last_calls += [('update', 'OK           ', 3, None)]
 
576
        self.assertEqual(last_calls, mypb.calls)
 
577
 
 
578
        # a skip
 
579
        result.startTest(dummy_test)
 
580
        last_calls += [('update', '...tyle_quiet', 3, None)]
 
581
        self.assertEqual(last_calls, mypb.calls)
 
582
        result.addSkipped(dummy_test, dummy_error)
 
583
        last_calls += [('update', 'SKIP         ', 4, None)]
 
584
        self.assertEqual(last_calls, mypb.calls)
 
585
 
 
586
    def test_elapsed_time_with_benchmarking(self):
 
587
        result = bzrlib.tests._MyResult(self._log_file,
 
588
                                        descriptions=0,
 
589
                                        verbosity=1,
 
590
                                        )
 
591
        result._recordTestStartTime()
 
592
        time.sleep(0.003)
 
593
        result.extractBenchmarkTime(self)
 
594
        timed_string = result._testTimeString()
 
595
        # without explicit benchmarking, we should get a simple time.
 
596
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
 
597
        # if a benchmark time is given, we want a x of y style result.
 
598
        self.time(time.sleep, 0.001)
 
599
        result.extractBenchmarkTime(self)
 
600
        timed_string = result._testTimeString()
 
601
        self.assertContainsRe(timed_string, "^   [ 1-9][0-9]ms/   [ 1-9][0-9]ms$")
 
602
        # extracting the time from a non-bzrlib testcase sets to None
 
603
        result._recordTestStartTime()
 
604
        result.extractBenchmarkTime(
 
605
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
 
606
        timed_string = result._testTimeString()
 
607
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
 
608
        # cheat. Yes, wash thy mouth out with soap.
 
609
        self._benchtime = None
 
610
 
 
611
    def test_assigned_benchmark_file_stores_date(self):
 
612
        output = StringIO()
 
613
        result = bzrlib.tests._MyResult(self._log_file,
 
614
                                        descriptions=0,
 
615
                                        verbosity=1,
 
616
                                        bench_history=output
 
617
                                        )
 
618
        output_string = output.getvalue()
 
619
        # if you are wondering about the regexp please read the comment in
 
620
        # test_bench_history (bzrlib.tests.test_selftest.TestRunner)
 
621
        # XXX: what comment?  -- Andrew Bennetts
 
622
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
623
 
 
624
    def test_benchhistory_records_test_times(self):
 
625
        result_stream = StringIO()
 
626
        result = bzrlib.tests._MyResult(
 
627
            self._log_file,
 
628
            descriptions=0,
 
629
            verbosity=1,
 
630
            bench_history=result_stream
 
631
            )
 
632
 
 
633
        # we want profile a call and check that its test duration is recorded
 
634
        # make a new test instance that when run will generate a benchmark
 
635
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
636
        # execute the test, which should succeed and record times
 
637
        example_test_case.run(result)
 
638
        lines = result_stream.getvalue().splitlines()
 
639
        self.assertEqual(2, len(lines))
 
640
        self.assertContainsRe(lines[1],
 
641
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
 
642
            "._time_hello_world_encoding")
 
643
 
 
644
    def _time_hello_world_encoding(self):
 
645
        """Profile two sleep calls
 
646
        
 
647
        This is used to exercise the test framework.
 
648
        """
 
649
        self.time(unicode, 'hello', errors='replace')
 
650
        self.time(unicode, 'world', errors='replace')
 
651
 
 
652
    def test_lsprofiling(self):
 
653
        """Verbose test result prints lsprof statistics from test cases."""
 
654
        try:
 
655
            import bzrlib.lsprof
 
656
        except ImportError:
 
657
            raise TestSkipped("lsprof not installed.")
 
658
        result_stream = StringIO()
 
659
        result = bzrlib.tests._MyResult(
 
660
            unittest._WritelnDecorator(result_stream),
 
661
            descriptions=0,
 
662
            verbosity=2,
 
663
            )
 
664
        # we want profile a call of some sort and check it is output by
 
665
        # addSuccess. We dont care about addError or addFailure as they
 
666
        # are not that interesting for performance tuning.
 
667
        # make a new test instance that when run will generate a profile
 
668
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
669
        example_test_case._gather_lsprof_in_benchmarks = True
 
670
        # execute the test, which should succeed and record profiles
 
671
        example_test_case.run(result)
 
672
        # lsprofile_something()
 
673
        # if this worked we want 
 
674
        # LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
 
675
        #    CallCount    Recursive    Total(ms)   Inline(ms) module:lineno(function)
 
676
        # (the lsprof header)
 
677
        # ... an arbitrary number of lines
 
678
        # and the function call which is time.sleep.
 
679
        #           1        0            ???         ???       ???(sleep) 
 
680
        # and then repeated but with 'world', rather than 'hello'.
 
681
        # this should appear in the output stream of our test result.
 
682
        output = result_stream.getvalue()
 
683
        self.assertContainsRe(output,
 
684
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
 
685
        self.assertContainsRe(output,
 
686
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
 
687
        self.assertContainsRe(output,
 
688
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
689
        self.assertContainsRe(output,
 
690
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
 
691
 
 
692
 
 
693
class TestRunner(TestCase):
 
694
 
 
695
    def dummy_test(self):
 
696
        pass
 
697
 
 
698
    def run_test_runner(self, testrunner, test):
 
699
        """Run suite in testrunner, saving global state and restoring it.
 
700
 
 
701
        This current saves and restores:
 
702
        TestCaseInTempDir.TEST_ROOT
 
703
        
 
704
        There should be no tests in this file that use bzrlib.tests.TextTestRunner
 
705
        without using this convenience method, because of our use of global state.
 
706
        """
 
707
        old_root = TestCaseInTempDir.TEST_ROOT
 
708
        try:
 
709
            TestCaseInTempDir.TEST_ROOT = None
 
710
            return testrunner.run(test)
 
711
        finally:
 
712
            TestCaseInTempDir.TEST_ROOT = old_root
 
713
 
 
714
    def test_accepts_and_uses_pb_parameter(self):
 
715
        test = TestRunner('dummy_test')
 
716
        mypb = MockProgress()
 
717
        self.assertEqual([], mypb.calls)
 
718
        runner = TextTestRunner(stream=self._log_file, pb=mypb)
 
719
        result = self.run_test_runner(runner, test)
 
720
        self.assertEqual(1, result.testsRun)
 
721
        self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
 
722
        self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
 
723
        self.assertEqual(('update', 'OK           ', 1, None), mypb.calls[2])
 
724
        self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
 
725
        self.assertEqual(('clear',), mypb.calls[4])
 
726
        self.assertEqual(5, len(mypb.calls))
 
727
 
 
728
    def test_skipped_test(self):
 
729
        # run a test that is skipped, and check the suite as a whole still
 
730
        # succeeds.
 
731
        # skipping_test must be hidden in here so it's not run as a real test
 
732
        def skipping_test():
 
733
            raise TestSkipped('test intentionally skipped')
 
734
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
735
        test = unittest.FunctionTestCase(skipping_test)
 
736
        result = self.run_test_runner(runner, test)
 
737
        self.assertTrue(result.wasSuccessful())
 
738
 
 
739
    def test_bench_history(self):
 
740
        # tests that the running the benchmark produces a history file
 
741
        # containing a timestamp and the revision id of the bzrlib source which
 
742
        # was tested.
 
743
        workingtree = _get_bzr_source_tree()
 
744
        test = TestRunner('dummy_test')
 
745
        output = StringIO()
 
746
        runner = TextTestRunner(stream=self._log_file, bench_history=output)
 
747
        result = self.run_test_runner(runner, test)
 
748
        output_string = output.getvalue()
 
749
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
750
        if workingtree is not None:
 
751
            revision_id = workingtree.get_parent_ids()[0]
 
752
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
753
 
 
754
    def test_success_log_deleted(self):
 
755
        """Successful tests have their log deleted"""
 
756
 
 
757
        class LogTester(TestCase):
 
758
 
 
759
            def test_success(self):
 
760
                self.log('this will be removed\n')
 
761
 
 
762
        sio = cStringIO.StringIO()
 
763
        runner = TextTestRunner(stream=sio)
 
764
        test = LogTester('test_success')
 
765
        result = self.run_test_runner(runner, test)
 
766
 
 
767
        log = test._get_log()
 
768
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
769
        self.assertEqual('', test._log_contents)
 
770
        self.assertIs(None, test._log_file_name)
 
771
 
 
772
    def test_fail_log_kept(self):
 
773
        """Failed tests have their log kept"""
 
774
 
 
775
        class LogTester(TestCase):
 
776
 
 
777
            def test_fail(self):
 
778
                self.log('this will be kept\n')
 
779
                self.fail('this test fails')
 
780
 
 
781
        sio = cStringIO.StringIO()
 
782
        runner = TextTestRunner(stream=sio)
 
783
        test = LogTester('test_fail')
 
784
        result = self.run_test_runner(runner, test)
 
785
 
 
786
        text = sio.getvalue()
 
787
        self.assertContainsRe(text, 'this will be kept')
 
788
        self.assertContainsRe(text, 'this test fails')
 
789
 
 
790
        log = test._get_log()
 
791
        self.assertContainsRe(log, 'this will be kept')
 
792
        self.assertEqual(log, test._log_contents)
 
793
 
 
794
    def test_error_log_kept(self):
 
795
        """Tests with errors have their log kept"""
 
796
 
 
797
        class LogTester(TestCase):
 
798
 
 
799
            def test_error(self):
 
800
                self.log('this will be kept\n')
 
801
                raise ValueError('random exception raised')
 
802
 
 
803
        sio = cStringIO.StringIO()
 
804
        runner = TextTestRunner(stream=sio)
 
805
        test = LogTester('test_error')
 
806
        result = self.run_test_runner(runner, test)
 
807
 
 
808
        text = sio.getvalue()
 
809
        self.assertContainsRe(text, 'this will be kept')
 
810
        self.assertContainsRe(text, 'random exception raised')
 
811
 
 
812
        log = test._get_log()
 
813
        self.assertContainsRe(log, 'this will be kept')
 
814
        self.assertEqual(log, test._log_contents)
 
815
 
 
816
 
 
817
class TestTestCase(TestCase):
 
818
    """Tests that test the core bzrlib TestCase."""
 
819
 
 
820
    def inner_test(self):
 
821
        # the inner child test
 
822
        note("inner_test")
 
823
 
 
824
    def outer_child(self):
 
825
        # the outer child test
 
826
        note("outer_start")
 
827
        self.inner_test = TestTestCase("inner_child")
 
828
        result = bzrlib.tests._MyResult(self._log_file,
 
829
                                        descriptions=0,
 
830
                                        verbosity=1)
 
831
        self.inner_test.run(result)
 
832
        note("outer finish")
 
833
 
 
834
    def test_trace_nesting(self):
 
835
        # this tests that each test case nests its trace facility correctly.
 
836
        # we do this by running a test case manually. That test case (A)
 
837
        # should setup a new log, log content to it, setup a child case (B),
 
838
        # which should log independently, then case (A) should log a trailer
 
839
        # and return.
 
840
        # we do two nested children so that we can verify the state of the 
 
841
        # logs after the outer child finishes is correct, which a bad clean
 
842
        # up routine in tearDown might trigger a fault in our test with only
 
843
        # one child, we should instead see the bad result inside our test with
 
844
        # the two children.
 
845
        # the outer child test
 
846
        original_trace = bzrlib.trace._trace_file
 
847
        outer_test = TestTestCase("outer_child")
 
848
        result = bzrlib.tests._MyResult(self._log_file,
 
849
                                        descriptions=0,
 
850
                                        verbosity=1)
 
851
        outer_test.run(result)
 
852
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
 
853
 
 
854
    def method_that_times_a_bit_twice(self):
 
855
        # call self.time twice to ensure it aggregates
 
856
        self.time(time.sleep, 0.007)
 
857
        self.time(time.sleep, 0.007)
 
858
 
 
859
    def test_time_creates_benchmark_in_result(self):
 
860
        """Test that the TestCase.time() method accumulates a benchmark time."""
 
861
        sample_test = TestTestCase("method_that_times_a_bit_twice")
 
862
        output_stream = StringIO()
 
863
        result = bzrlib.tests._MyResult(
 
864
            unittest._WritelnDecorator(output_stream),
 
865
            descriptions=0,
 
866
            verbosity=2)
 
867
        sample_test.run(result)
 
868
        self.assertContainsRe(
 
869
            output_stream.getvalue(),
 
870
            "[1-9][0-9]ms/   [1-9][0-9]ms\n$")
 
871
        
 
872
    def test__gather_lsprof_in_benchmarks(self):
 
873
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
 
874
        
 
875
        Each self.time() call is individually and separately profiled.
 
876
        """
 
877
        try:
 
878
            import bzrlib.lsprof
 
879
        except ImportError:
 
880
            raise TestSkipped("lsprof not installed.")
 
881
        # overrides the class member with an instance member so no cleanup 
 
882
        # needed.
 
883
        self._gather_lsprof_in_benchmarks = True
 
884
        self.time(time.sleep, 0.000)
 
885
        self.time(time.sleep, 0.003)
 
886
        self.assertEqual(2, len(self._benchcalls))
 
887
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
 
888
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
 
889
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
 
890
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
 
891
 
 
892
 
 
893
@symbol_versioning.deprecated_function(zero_eleven)
 
894
def sample_deprecated_function():
 
895
    """A deprecated function to test applyDeprecated with."""
 
896
    return 2
 
897
 
 
898
 
 
899
def sample_undeprecated_function(a_param):
 
900
    """A undeprecated function to test applyDeprecated with."""
 
901
 
 
902
 
 
903
class ApplyDeprecatedHelper(object):
 
904
    """A helper class for ApplyDeprecated tests."""
 
905
 
 
906
    @symbol_versioning.deprecated_method(zero_eleven)
 
907
    def sample_deprecated_method(self, param_one):
 
908
        """A deprecated method for testing with."""
 
909
        return param_one
 
910
 
 
911
    def sample_normal_method(self):
 
912
        """A undeprecated method."""
 
913
 
 
914
    @symbol_versioning.deprecated_method(zero_ten)
 
915
    def sample_nested_deprecation(self):
 
916
        return sample_deprecated_function()
 
917
 
 
918
 
387
919
class TestExtraAssertions(TestCase):
388
920
    """Tests for new test assertions in bzrlib test suite"""
389
921
 
392
924
        self.assertIsInstance(u'', basestring)
393
925
        self.assertRaises(AssertionError, self.assertIsInstance, None, int)
394
926
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
 
927
 
 
928
    def test_assertEndsWith(self):
 
929
        self.assertEndsWith('foo', 'oo')
 
930
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
 
931
 
 
932
    def test_applyDeprecated_not_deprecated(self):
 
933
        sample_object = ApplyDeprecatedHelper()
 
934
        # calling an undeprecated callable raises an assertion
 
935
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
936
            sample_object.sample_normal_method)
 
937
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
938
            sample_undeprecated_function, "a param value")
 
939
        # calling a deprecated callable (function or method) with the wrong
 
940
        # expected deprecation fails.
 
941
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
942
            sample_object.sample_deprecated_method, "a param value")
 
943
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
944
            sample_deprecated_function)
 
945
        # calling a deprecated callable (function or method) with the right
 
946
        # expected deprecation returns the functions result.
 
947
        self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
 
948
            sample_object.sample_deprecated_method, "a param value"))
 
949
        self.assertEqual(2, self.applyDeprecated(zero_eleven,
 
950
            sample_deprecated_function))
 
951
        # calling a nested deprecation with the wrong deprecation version
 
952
        # fails even if a deeper nested function was deprecated with the 
 
953
        # supplied version.
 
954
        self.assertRaises(AssertionError, self.applyDeprecated,
 
955
            zero_eleven, sample_object.sample_nested_deprecation)
 
956
        # calling a nested deprecation with the right deprecation value
 
957
        # returns the calls result.
 
958
        self.assertEqual(2, self.applyDeprecated(zero_ten,
 
959
            sample_object.sample_nested_deprecation))
 
960
 
 
961
    def test_callDeprecated(self):
 
962
        def testfunc(be_deprecated, result=None):
 
963
            if be_deprecated is True:
 
964
                symbol_versioning.warn('i am deprecated', DeprecationWarning, 
 
965
                                       stacklevel=1)
 
966
            return result
 
967
        result = self.callDeprecated(['i am deprecated'], testfunc, True)
 
968
        self.assertIs(None, result)
 
969
        result = self.callDeprecated([], testfunc, False, 'result')
 
970
        self.assertEqual('result', result)
 
971
        self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
 
972
        self.callDeprecated([], testfunc, be_deprecated=False)
 
973
 
 
974
 
 
975
class TestConvenienceMakers(TestCaseWithTransport):
 
976
    """Test for the make_* convenience functions."""
 
977
 
 
978
    def test_make_branch_and_tree_with_format(self):
 
979
        # we should be able to supply a format to make_branch_and_tree
 
980
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
981
        self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
 
982
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
 
983
                              bzrlib.bzrdir.BzrDirMetaFormat1)
 
984
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
 
985
                              bzrlib.bzrdir.BzrDirFormat6)
 
986
 
 
987
    def test_make_branch_and_mutable_tree(self):
 
988
        # we should be able to get a new branch and a mutable tree from
 
989
        # TestCaseWithTransport
 
990
        tree = self.make_branch_and_memory_tree('a')
 
991
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
 
992
 
 
993
 
 
994
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
 
995
 
 
996
    def test_make_tree_for_sftp_branch(self):
 
997
        """Transports backed by local directories create local trees."""
 
998
 
 
999
        tree = self.make_branch_and_tree('t1')
 
1000
        base = tree.bzrdir.root_transport.base
 
1001
        self.failIf(base.startswith('sftp'),
 
1002
                'base %r is on sftp but should be local' % base)
 
1003
        self.assertEquals(tree.bzrdir.root_transport,
 
1004
                tree.branch.bzrdir.root_transport)
 
1005
        self.assertEquals(tree.bzrdir.root_transport,
 
1006
                tree.branch.repository.bzrdir.root_transport)
 
1007
 
 
1008
 
 
1009
class TestSelftest(TestCase):
 
1010
    """Tests of bzrlib.tests.selftest."""
 
1011
 
 
1012
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
 
1013
        factory_called = []
 
1014
        def factory():
 
1015
            factory_called.append(True)
 
1016
            return TestSuite()
 
1017
        out = StringIO()
 
1018
        err = StringIO()
 
1019
        self.apply_redirected(out, err, None, bzrlib.tests.selftest, 
 
1020
            test_suite_factory=factory)
 
1021
        self.assertEqual([True], factory_called)