~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: Robert Collins
  • Date: 2005-09-06 09:50:31 UTC
  • mto: (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: robertc@robertcollins.net-20050906095031-251e9bdf97a4817f
make show_diff redirectable

Show diffs side-by-side

added added

removed removed

Lines of Context:
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, FunctionalTestCase
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)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
 
 
 
25
 
 
26
class BzrTestBase(InTempDir):
 
27
    """bzr-specific test base class"""
91
28
    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
29
        retcode = kwargs.get('retcode', 0)
102
30
        result = self.apply_redirected(None, None, None,
103
31
                                       bzrlib.commands.run_bzr, args)
104
32
        self.assertEquals(result, retcode)
105
33
        
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
34
 
294
35
def selftest(verbose=False, pattern=".*"):
295
36
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern)
304
45
    import shutil
305
46
    import time
306
47
    import sys
 
48
    import unittest
307
49
 
308
50
    global MODULES_TO_TEST, MODULES_TO_DOCTEST
309
51
 
310
52
    testmod_names = \
311
 
                  ['bzrlib.selftest.MetaTestLog',
312
 
                   'bzrlib.selftest.test_parent',
 
53
                  ['bzrlib.selftest.whitebox',
 
54
                   'bzrlib.selftest.versioning',
 
55
                   'bzrlib.selftest.testfetch',
313
56
                   'bzrlib.selftest.testinv',
314
 
                   'bzrlib.selftest.testfetch',
315
 
                   'bzrlib.selftest.versioning',
316
 
                   'bzrlib.selftest.whitebox',
317
57
                   'bzrlib.selftest.testmerge3',
318
 
                   'bzrlib.selftest.testmerge',
319
58
                   'bzrlib.selftest.testhashcache',
320
59
                   'bzrlib.selftest.teststatus',
321
60
                   'bzrlib.selftest.testlog',
322
61
                   'bzrlib.selftest.blackbox',
323
62
                   'bzrlib.selftest.testrevisionnamespaces',
324
63
                   'bzrlib.selftest.testbranch',
325
 
                   'bzrlib.selftest.testremotebranch',
326
64
                   'bzrlib.selftest.testrevision',
327
65
                   'bzrlib.selftest.test_merge_core',
328
66
                   'bzrlib.selftest.test_smart_add',
329
67
                   'bzrlib.selftest.testdiff',
330
 
                   'bzrlib.selftest.test_xml',
331
 
                   'bzrlib.fetch',
332
 
                   'bzrlib.selftest.teststore',
333
 
                   'bzrlib.selftest.testgraph',
 
68
                   'bzrlib.fetch'
334
69
                   ]
335
70
 
336
71
    for m in (bzrlib.store, bzrlib.inventory, bzrlib.branch,