← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: Martin Pool
  • Date: 2005-08-24 08:59:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050824085932-c61f1f1f1c930e13
- Add a simple UIFactory 

  The idea of this is to let a client of bzrlib set some 
  policy about how output is displayed.

  In this revision all that's done is that progress bars
  are constructed by a policy established by the application
  rather than being randomly constructed in the library 
  or passed down the calls.  This avoids progress bars
  popping up while running the test suite and cleans up
  some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/__init__.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import logging
19
 
import unittest
20
 
import tempfile
21
 
import os
22
 
import sys
23
 
import subprocess
24
 
 
25
 
from testsweet import run_suite
 
18
from testsweet import TestCase, run_suite, InTempDir
26
19
import bzrlib.commands
27
 
 
28
 
import bzrlib.trace
29
20
import bzrlib.fetch
30
21
 
31
 
 
32
22
MODULES_TO_TEST = []
33
23
MODULES_TO_DOCTEST = []
34
24
 
35
 
from logging import debug, warning, error
36
 
 
37
 
class CommandFailed(Exception):
38
 
    pass
39
 
 
40
 
class TestCase(unittest.TestCase):
41
 
    """Base class for bzr unit tests.
42
 
    
43
 
    Tests that need access to disk resources should subclass 
44
 
    TestCaseInTempDir not TestCase.
45
 
 
46
 
    Error and debug log messages are redirected from their usual
47
 
    location into a temporary file, the contents of which can be
48
 
    retrieved by _get_log().
49
 
       
50
 
    There are also convenience functions to invoke bzr's command-line
51
 
    routine, and to build and check bzr trees."""
52
 
 
53
 
    BZRPATH = 'bzr'
54
 
 
55
 
    def setUp(self):
56
 
        # this replaces the default testsweet.TestCase; we don't want logging changed
57
 
        unittest.TestCase.setUp(self)
58
 
        bzrlib.trace.disable_default_logging()
59
 
        self._enable_file_logging()
60
 
 
61
 
 
62
 
    def _enable_file_logging(self):
63
 
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
64
 
 
65
 
        self._log_file = os.fdopen(fileno, 'w+')
66
 
 
67
 
        hdlr = logging.StreamHandler(self._log_file)
68
 
        hdlr.setLevel(logging.DEBUG)
69
 
        hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
70
 
        logging.getLogger('').addHandler(hdlr)
71
 
        logging.getLogger('').setLevel(logging.DEBUG)
72
 
        self._log_hdlr = hdlr
73
 
        debug('opened log file %s', name)
74
 
        
75
 
        self._log_file_name = name
76
 
 
77
 
        
78
 
    def tearDown(self):
79
 
        logging.getLogger('').removeHandler(self._log_hdlr)
80
 
        bzrlib.trace.enable_default_logging()
81
 
        logging.debug('%s teardown', self.id())
82
 
        self._log_file.close()
83
 
        unittest.TestCase.tearDown(self)
84
 
 
85
 
 
86
 
    def log(self, *args):
87
 
        logging.debug(*args)
88
 
 
89
 
    def _get_log(self):
90
 
        """Return as a string the log for this test"""
91
 
        return open(self._log_file_name).read()
92
 
 
 
25
 
 
26
class BzrTestBase(InTempDir):
 
27
    """bzr-specific test base class"""
93
28
    def run_bzr(self, *args, **kwargs):
94
 
        """Invoke bzr, as if it were run from the command line.
95
 
 
96
 
        This should be the main method for tests that want to exercise the
97
 
        overall behavior of the bzr application (rather than a unit test
98
 
        or a functional test of the library.)
99
 
 
100
 
        Much of the old code runs bzr by forking a new copy of Python, but
101
 
        that is slower, harder to debug, and generally not necessary.
102
 
        """
103
29
        retcode = kwargs.get('retcode', 0)
104
 
        result = self.apply_redirected(None, None, None,
105
 
                                       bzrlib.commands.run_bzr, args)
106
 
        self.assertEquals(result, retcode)
107
 
        
108
 
        
109
 
    def check_inventory_shape(self, inv, shape):
110
 
        """
111
 
        Compare an inventory to a list of expected names.
112
 
 
113
 
        Fail if they are not precisely equal.
114
 
        """
115
 
        extras = []
116
 
        shape = list(shape)             # copy
117
 
        for path, ie in inv.entries():
118
 
            name = path.replace('\\', '/')
119
 
            if ie.kind == 'dir':
120
 
                name = name + '/'
121
 
            if name in shape:
122
 
                shape.remove(name)
123
 
            else:
124
 
                extras.append(name)
125
 
        if shape:
126
 
            self.fail("expected paths not found in inventory: %r" % shape)
127
 
        if extras:
128
 
            self.fail("unexpected paths found in inventory: %r" % extras)
129
 
 
130
 
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
131
 
                         a_callable=None, *args, **kwargs):
132
 
        """Call callable with redirected std io pipes.
133
 
 
134
 
        Returns the return code."""
135
 
        from StringIO import StringIO
136
 
        if not callable(a_callable):
137
 
            raise ValueError("a_callable must be callable.")
138
 
        if stdin is None:
139
 
            stdin = StringIO("")
140
 
        if stdout is None:
141
 
            stdout = self._log_file
142
 
        if stderr is None:
143
 
            stderr = self._log_file
144
 
        real_stdin = sys.stdin
145
 
        real_stdout = sys.stdout
146
 
        real_stderr = sys.stderr
147
 
        try:
148
 
            sys.stdout = stdout
149
 
            sys.stderr = stderr
150
 
            sys.stdin = stdin
151
 
            return a_callable(*args, **kwargs)
152
 
        finally:
153
 
            sys.stdout = real_stdout
154
 
            sys.stderr = real_stderr
155
 
            sys.stdin = real_stdin
156
 
 
157
 
 
158
 
BzrTestBase = TestCase
159
 
 
160
 
     
161
 
class TestCaseInTempDir(TestCase):
162
 
    """Derived class that runs a test within a temporary directory.
163
 
 
164
 
    This is useful for tests that need to create a branch, etc.
165
 
 
166
 
    The directory is created in a slightly complex way: for each
167
 
    Python invocation, a new temporary top-level directory is created.
168
 
    All test cases create their own directory within that.  If the
169
 
    tests complete successfully, the directory is removed.
170
 
 
171
 
    InTempDir is an old alias for FunctionalTestCase.
172
 
    """
173
 
 
174
 
    TEST_ROOT = None
175
 
    _TEST_NAME = 'test'
176
 
    OVERRIDE_PYTHON = 'python'
177
 
 
178
 
    def check_file_contents(self, filename, expect):
179
 
        self.log("check contents of file %s" % filename)
180
 
        contents = file(filename, 'r').read()
181
 
        if contents != expect:
182
 
            self.log("expected: %r" % expect)
183
 
            self.log("actually: %r" % contents)
184
 
            self.fail("contents of %s not as expected")
185
 
 
186
 
    def _make_test_root(self):
187
 
        import os
188
 
        import shutil
189
 
        import tempfile
190
 
        
191
 
        if TestCaseInTempDir.TEST_ROOT is not None:
192
 
            return
193
 
        TestCaseInTempDir.TEST_ROOT = os.path.abspath(
194
 
                                 tempfile.mkdtemp(suffix='.tmp',
195
 
                                                  prefix=self._TEST_NAME + '-',
196
 
                                                  dir=os.curdir))
197
 
    
198
 
        # make a fake bzr directory there to prevent any tests propagating
199
 
        # up onto the source directory's real branch
200
 
        os.mkdir(os.path.join(TestCaseInTempDir.TEST_ROOT, '.bzr'))
201
 
 
202
 
    def setUp(self):
203
 
        super(TestCaseInTempDir, self).setUp()
204
 
        import os
205
 
        self._make_test_root()
206
 
        self._currentdir = os.getcwdu()
207
 
        short_id = self.id().replace('bzrlib.selftest.', '')
208
 
        self.test_dir = os.path.join(self.TEST_ROOT, short_id)
209
 
        os.mkdir(self.test_dir)
210
 
        os.chdir(self.test_dir)
211
 
        
212
 
    def tearDown(self):
213
 
        import os
214
 
        os.chdir(self._currentdir)
215
 
        super(TestCaseInTempDir, self).tearDown()
216
 
 
217
 
    def _formcmd(self, cmd):
218
 
        if isinstance(cmd, basestring):
219
 
            cmd = cmd.split()
220
 
        if cmd[0] == 'bzr':
221
 
            cmd[0] = self.BZRPATH
222
 
            if self.OVERRIDE_PYTHON:
223
 
                cmd.insert(0, self.OVERRIDE_PYTHON)
224
 
        self.log('$ %r' % cmd)
225
 
        return cmd
226
 
 
227
 
    def runcmd(self, cmd, retcode=0):
228
 
        """Run one command and check the return code.
229
 
 
230
 
        Returns a tuple of (stdout,stderr) strings.
231
 
 
232
 
        If a single string is based, it is split into words.
233
 
        For commands that are not simple space-separated words, please
234
 
        pass a list instead."""
235
 
        cmd = self._formcmd(cmd)
236
 
        self.log('$ ' + ' '.join(cmd))
237
 
        actual_retcode = subprocess.call(cmd, stdout=self._log_file,
238
 
                                         stderr=self._log_file)
239
 
        if retcode != actual_retcode:
240
 
            raise CommandFailed("test failed: %r returned %d, expected %d"
241
 
                                % (cmd, actual_retcode, retcode))
242
 
 
243
 
    def backtick(self, cmd, retcode=0):
244
 
        """Run a command and return its output"""
245
 
        cmd = self._formcmd(cmd)
246
 
        child = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=self._log_file)
247
 
        outd, errd = child.communicate()
248
 
        self.log(outd)
249
 
        actual_retcode = child.wait()
250
 
 
251
 
        outd = outd.replace('\r', '')
252
 
 
253
 
        if retcode != actual_retcode:
254
 
            raise CommandFailed("test failed: %r returned %d, expected %d"
255
 
                                % (cmd, actual_retcode, retcode))
256
 
 
257
 
        return outd
258
 
 
259
 
 
260
 
 
261
 
    def build_tree(self, shape):
262
 
        """Build a test tree according to a pattern.
263
 
 
264
 
        shape is a sequence of file specifications.  If the final
265
 
        character is '/', a directory is created.
266
 
 
267
 
        This doesn't add anything to a branch.
268
 
        """
269
 
        # XXX: It's OK to just create them using forward slashes on windows?
270
 
        import os
271
 
        for name in shape:
272
 
            assert isinstance(name, basestring)
273
 
            if name[-1] == '/':
274
 
                os.mkdir(name[:-1])
275
 
            else:
276
 
                f = file(name, 'wt')
277
 
                print >>f, "contents of", name
278
 
                f.close()
279
 
                
280
 
 
281
 
 
282
 
class MetaTestLog(TestCase):
283
 
    def test_logging(self):
284
 
        """Test logs are captured when a test fails."""
285
 
        logging.info('an info message')
286
 
        warning('something looks dodgy...')
287
 
        logging.debug('hello, test is running')
288
 
        ##assert 0
289
 
 
290
 
 
291
 
def selftest(verbose=False, pattern=".*"):
292
 
    """Run the whole test suite under the enhanced runner"""
293
 
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern)
294
 
 
295
 
 
296
 
def test_suite():
297
 
    """Build and return TestSuite for the whole program."""
298
 
    from bzrlib.selftest.TestUtil import TestLoader, TestSuite
 
30
        self.assertEquals(bzrlib.commands.run_bzr(args), retcode)
 
31
        
 
32
 
 
33
def selftest(verbose=False):
 
34
    from unittest import TestLoader, TestSuite
299
35
    import bzrlib, bzrlib.store, bzrlib.inventory, bzrlib.branch
300
36
    import bzrlib.osutils, bzrlib.commands, bzrlib.merge3, bzrlib.plugin
301
37
    from doctest import DocTestSuite
303
39
    import shutil
304
40
    import time
305
41
    import sys
 
42
    import unittest
306
43
 
307
44
    global MODULES_TO_TEST, MODULES_TO_DOCTEST
308
45
 
309
46
    testmod_names = \
310
 
                  ['bzrlib.selftest.MetaTestLog',
 
47
                  ['bzrlib.selftest.whitebox',
 
48
                   'bzrlib.selftest.versioning',
311
49
                   'bzrlib.selftest.testinv',
312
 
                   'bzrlib.selftest.versioning',
313
50
                   'bzrlib.selftest.testmerge3',
314
51
                   'bzrlib.selftest.testhashcache',
315
52
                   'bzrlib.selftest.teststatus',
316
53
                   'bzrlib.selftest.testlog',
 
54
                   'bzrlib.selftest.blackbox',
317
55
                   'bzrlib.selftest.testrevisionnamespaces',
318
56
                   'bzrlib.selftest.testbranch',
319
57
                   'bzrlib.selftest.testrevision',
320
 
                   'bzrlib.selftest.test_merge_core',
321
 
                   'bzrlib.selftest.test_smart_add',
 
58
                   'bzrlib.merge_core',
322
59
                   'bzrlib.selftest.testdiff',
323
 
                   'bzrlib.selftest.test_parent',
324
 
                   'bzrlib.selftest.test_xml',
325
 
                   'bzrlib.selftest.testfetch',
326
 
                   'bzrlib.selftest.whitebox',
327
 
                   'bzrlib.selftest.teststore',
328
 
                   'bzrlib.selftest.blackbox',
 
60
                   'bzrlib.fetch'
329
61
                   ]
330
62
 
331
63
    for m in (bzrlib.store, bzrlib.inventory, bzrlib.branch,
335
67
 
336
68
    TestCase.BZRPATH = os.path.join(os.path.realpath(os.path.dirname(bzrlib.__path__[0])), 'bzr')
337
69
    print '%-30s %s' % ('bzr binary', TestCase.BZRPATH)
 
70
 
338
71
    print
 
72
 
339
73
    suite = TestSuite()
 
74
 
340
75
    suite.addTest(TestLoader().loadTestsFromNames(testmod_names))
 
76
 
341
77
    for m in MODULES_TO_TEST:
342
78
         suite.addTest(TestLoader().loadTestsFromModule(m))
 
79
 
343
80
    for m in (MODULES_TO_DOCTEST):
344
81
        suite.addTest(DocTestSuite(m))
 
82
 
345
83
    for p in bzrlib.plugin.all_plugins:
346
84
        if hasattr(p, 'test_suite'):
347
85
            suite.addTest(p.test_suite())
348
 
    return suite
 
86
 
 
87
    import bzrlib.merge_core
 
88
    suite.addTest(unittest.makeSuite(bzrlib.merge_core.MergeTest, 'test_'))
 
89
 
 
90
    return run_suite(suite, 'testbzr', verbose=verbose)
 
91
 
 
92
 
349
93