← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: Aaron Bentley
  • Date: 2005-09-12 13:48:32 UTC
  • mfrom: (1185.3.4)
  • mto: (1185.1.16)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: abentley@panoramicfeedback.com-20050912134832-c23db11dc63170b6
Merged from mpool

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