/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_selftest.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-22 16:28:47 UTC
  • mto: This revision was merged to the branch mainline in revision 4922.
  • Revision ID: john@arbash-meinel.com-20091222162847-tvnsc69to4l4uf5r
Implement a permute_for_extension helper.

Use it for all of the 'simple' extension permutations.
It basically permutes all tests in the current module, by setting TestCase.module.
Which works well for most of our extension tests. Some had more advanced
handling of permutations (extra permutations, custom vars, etc.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_selftest.py
 
1
# Copyright (C) 2005, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
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.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""UI tests for the test framework."""
 
18
 
 
19
import bzrlib.transport
 
20
from bzrlib import (
 
21
    benchmarks,
 
22
    tests,
 
23
    )
 
24
from bzrlib.errors import ParamikoNotPresent
 
25
from bzrlib.tests import (
 
26
                          features,
 
27
                          TestCase,
 
28
                          TestCaseInTempDir,
 
29
                          TestSkipped,
 
30
                          )
 
31
 
 
32
 
 
33
class SelfTestPatch:
 
34
 
 
35
    def get_params_passed_to_core(self, cmdline):
 
36
        params = []
 
37
        def selftest(*args, **kwargs):
 
38
            """Capture the arguments selftest was run with."""
 
39
            params.append((args, kwargs))
 
40
            return True
 
41
        # Yes this prevents using threads to run the test suite in parallel,
 
42
        # however we don't have a clean dependency injector for commands, 
 
43
        # and even if we did - we'd still be testing that the glue is wired
 
44
        # up correctly. XXX: TODO: Solve this testing problem.
 
45
        original_selftest = tests.selftest
 
46
        tests.selftest = selftest
 
47
        try:
 
48
            self.run_bzr(cmdline)
 
49
            return params[0]
 
50
        finally:
 
51
            tests.selftest = original_selftest
 
52
 
 
53
 
 
54
class TestOptionsWritingToDisk(TestCaseInTempDir, SelfTestPatch):
 
55
 
 
56
    def test_benchmark_runs_benchmark_tests(self):
 
57
        """selftest --benchmark should change the suite factory."""
 
58
        params = self.get_params_passed_to_core('selftest --benchmark')
 
59
        self.assertEqual(benchmarks.test_suite,
 
60
            params[1]['test_suite_factory'])
 
61
        self.assertNotEqual(None, params[1]['bench_history'])
 
62
        benchfile = open(".perf_history", "rt")
 
63
        try:
 
64
            lines = benchfile.readlines()
 
65
        finally:
 
66
            benchfile.close()
 
67
        # Because we don't run the actual test code no output is made to the
 
68
        # file.
 
69
        self.assertEqual(0, len(lines))
 
70
 
 
71
 
 
72
class TestOptions(TestCase, SelfTestPatch):
 
73
 
 
74
    def test_load_list(self):
 
75
        params = self.get_params_passed_to_core('selftest --load-list foo')
 
76
        self.assertEqual('foo', params[1]['load_list'])
 
77
 
 
78
    def test_transport_set_to_sftp(self):
 
79
        # Test that we can pass a transport to the selftest core - sftp
 
80
        # version.
 
81
        self.requireFeature(features.paramiko)
 
82
        params = self.get_params_passed_to_core('selftest --transport=sftp')
 
83
        self.assertEqual(bzrlib.transport.sftp.SFTPAbsoluteServer,
 
84
            params[1]["transport"])
 
85
 
 
86
    def test_transport_set_to_memory(self):
 
87
        # Test that we can pass a transport to the selftest core - memory
 
88
        # version.
 
89
        import bzrlib.transport.memory
 
90
        params = self.get_params_passed_to_core('selftest --transport=memory')
 
91
        self.assertEqual(bzrlib.transport.memory.MemoryServer,
 
92
            params[1]["transport"])
 
93
 
 
94
    def test_parameters_passed_to_core(self):
 
95
        params = self.get_params_passed_to_core('selftest --list-only')
 
96
        self.assertTrue("list_only" in params[1])
 
97
        params = self.get_params_passed_to_core('selftest --list-only selftest')
 
98
        self.assertTrue("list_only" in params[1])
 
99
        params = self.get_params_passed_to_core(['selftest', '--list-only',
 
100
            '--exclude', 'selftest'])
 
101
        self.assertTrue("list_only" in params[1])
 
102
        params = self.get_params_passed_to_core(['selftest', '--list-only',
 
103
            'selftest', '--randomize', 'now'])
 
104
        self.assertSubset(["list_only", "random_seed"], params[1])
 
105
 
 
106
    def test_starting_with(self):
 
107
        params = self.get_params_passed_to_core('selftest --starting-with foo')
 
108
        self.assertEqual(['foo'], params[1]['starting_with'])
 
109
 
 
110
    def test_starting_with_multiple_argument(self):
 
111
        params = self.get_params_passed_to_core(
 
112
            'selftest --starting-with foo --starting-with bar')
 
113
        self.assertEqual(['foo', 'bar'], params[1]['starting_with'])
 
114
 
 
115
    def test_subunit(self):
 
116
        self.requireFeature(features.subunit)
 
117
        params = self.get_params_passed_to_core('selftest --subunit')
 
118
        self.assertEqual(tests.SubUnitBzrRunner, params[1]['runner_class'])
 
119
 
 
120
    def _parse_test_list(self, lines, newlines_in_header=0):
 
121
        "Parse a list of lines into a tuple of 3 lists (header,body,footer)."
 
122
        in_header = newlines_in_header != 0
 
123
        in_footer = False
 
124
        header = []
 
125
        body = []
 
126
        footer = []
 
127
        header_newlines_found = 0
 
128
        for line in lines:
 
129
            if in_header:
 
130
                if line == '':
 
131
                    header_newlines_found += 1
 
132
                    if header_newlines_found >= newlines_in_header:
 
133
                        in_header = False
 
134
                        continue
 
135
                header.append(line)
 
136
            elif not in_footer:
 
137
                if line.startswith('-------'):
 
138
                    in_footer = True
 
139
                else:
 
140
                    body.append(line)
 
141
            else:
 
142
                footer.append(line)
 
143
        # If the last body line is blank, drop it off the list
 
144
        if len(body) > 0 and body[-1] == '':
 
145
            body.pop()
 
146
        return (header,body,footer)
 
147
 
 
148
    def test_list_only(self):
 
149
        # check that bzr selftest --list-only outputs no ui noise
 
150
        def selftest(*args, **kwargs):
 
151
            """Capture the arguments selftest was run with."""
 
152
            return True
 
153
        def outputs_nothing(cmdline):
 
154
            out,err = self.run_bzr(cmdline)
 
155
            (header,body,footer) = self._parse_test_list(out.splitlines())
 
156
            num_tests = len(body)
 
157
            self.assertLength(0, header)
 
158
            self.assertLength(0, footer)
 
159
            self.assertEqual('', err)
 
160
        # Yes this prevents using threads to run the test suite in parallel,
 
161
        # however we don't have a clean dependency injector for commands, 
 
162
        # and even if we did - we'd still be testing that the glue is wired
 
163
        # up correctly. XXX: TODO: Solve this testing problem.
 
164
        original_selftest = tests.selftest
 
165
        tests.selftest = selftest
 
166
        try:
 
167
            outputs_nothing('selftest --list-only')
 
168
            outputs_nothing('selftest --list-only selftest')
 
169
            outputs_nothing(['selftest', '--list-only', '--exclude', 'selftest'])
 
170
        finally:
 
171
            tests.selftest = original_selftest
 
172
 
 
173
    def test_lsprof_tests(self):
 
174
        params = self.get_params_passed_to_core('selftest --lsprof-tests')
 
175
        self.assertEqual(True, params[1]["lsprof_tests"])