← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: John Arbash Meinel
  • Date: 2005-09-15 21:35:53 UTC
  • mfrom: (907.1.57)
  • mto: (1393.2.1)
  • mto: This revision was merged to the branch mainline in revision 1396.
  • Revision ID: john@arbash-meinel.com-20050915213552-a6c83a5ef1e20897
(broken) Transport work is merged in. Tests do not pass yet.

Show diffs side-by-side

added added

removed removed

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