~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: Martin Pool
  • Date: 2005-07-05 08:37:09 UTC
  • Revision ID: mbp@sourcefrog.net-20050705083709-8a5107dea678b14a
- code to represent merges in regular text conflict form

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
 
from testsweet import TestBase, run_suite, InTempDir
19
 
 
20
 
MODULES_TO_TEST = []
21
 
MODULES_TO_DOCTEST = []
 
18
from unittest import TestResult, TestCase
 
19
 
 
20
try:
 
21
    import shutil
 
22
    from subprocess import call, Popen, PIPE
 
23
except ImportError, e:
 
24
    sys.stderr.write("testbzr: sorry, this test suite requires the subprocess module\n"
 
25
                     "this is shipped with python2.4 and available separately for 2.3\n")
 
26
    raise
 
27
 
 
28
 
 
29
class CommandFailed(Exception):
 
30
    pass
 
31
 
 
32
 
 
33
class TestBase(TestCase):
 
34
    """Base class for bzr test cases.
 
35
 
 
36
    Just defines some useful helper functions; doesn't actually test
 
37
    anything.
 
38
    """
 
39
    
 
40
    # TODO: Special methods to invoke bzr, so that we can run it
 
41
    # through a specified Python intepreter
 
42
 
 
43
    OVERRIDE_PYTHON = None # to run with alternative python 'python'
 
44
    BZRPATH = 'bzr'
 
45
 
 
46
    _log_buf = ""
 
47
 
 
48
 
 
49
    def formcmd(self, cmd):
 
50
        if isinstance(cmd, basestring):
 
51
            cmd = cmd.split()
 
52
 
 
53
        if cmd[0] == 'bzr':
 
54
            cmd[0] = self.BZRPATH
 
55
            if self.OVERRIDE_PYTHON:
 
56
                cmd.insert(0, self.OVERRIDE_PYTHON)
 
57
 
 
58
        self.log('$ %r' % cmd)
 
59
 
 
60
        return cmd
 
61
 
 
62
 
 
63
    def runcmd(self, cmd, retcode=0):
 
64
        """Run one command and check the return code.
 
65
 
 
66
        Returns a tuple of (stdout,stderr) strings.
 
67
 
 
68
        If a single string is based, it is split into words.
 
69
        For commands that are not simple space-separated words, please
 
70
        pass a list instead."""
 
71
        cmd = self.formcmd(cmd)
 
72
 
 
73
        self.log('$ ' + ' '.join(cmd))
 
74
        actual_retcode = call(cmd, stdout=self.TEST_LOG, stderr=self.TEST_LOG)
 
75
 
 
76
        if retcode != actual_retcode:
 
77
            raise CommandFailed("test failed: %r returned %d, expected %d"
 
78
                                % (cmd, actual_retcode, retcode))
 
79
 
 
80
 
 
81
    def backtick(self, cmd, retcode=0):
 
82
        """Run a command and return its output"""
 
83
        cmd = self.formcmd(cmd)
 
84
        child = Popen(cmd, stdout=PIPE, stderr=self.TEST_LOG)
 
85
        outd, errd = child.communicate()
 
86
        self.log(outd)
 
87
        actual_retcode = child.wait()
 
88
 
 
89
        outd = outd.replace('\r', '')
 
90
 
 
91
        if retcode != actual_retcode:
 
92
            raise CommandFailed("test failed: %r returned %d, expected %d"
 
93
                                % (cmd, actual_retcode, retcode))
 
94
 
 
95
        return outd
 
96
 
 
97
 
 
98
 
 
99
    def build_tree(self, shape):
 
100
        """Build a test tree according to a pattern.
 
101
 
 
102
        shape is a sequence of file specifications.  If the final
 
103
        character is '/', a directory is created.
 
104
 
 
105
        This doesn't add anything to a branch.
 
106
        """
 
107
        # XXX: It's OK to just create them using forward slashes on windows?
 
108
        import os
 
109
        for name in shape:
 
110
            assert isinstance(name, basestring)
 
111
            if name[-1] == '/':
 
112
                os.mkdir(name[:-1])
 
113
            else:
 
114
                f = file(name, 'wt')
 
115
                print >>f, "contents of", name
 
116
                f.close()
 
117
 
 
118
 
 
119
    def log(self, msg):
 
120
        """Log a message to a progress file"""
 
121
        self._log_buf = self._log_buf + str(msg) + '\n'
 
122
        print >>self.TEST_LOG, msg
 
123
 
 
124
 
 
125
    def check_inventory_shape(self, inv, shape):
 
126
        """
 
127
        Compare an inventory to a list of expected names.
 
128
 
 
129
        Fail if they are not precisely equal.
 
130
        """
 
131
        extras = []
 
132
        shape = list(shape)             # copy
 
133
        for path, ie in inv.entries():
 
134
            name = path.replace('\\', '/')
 
135
            if ie.kind == 'dir':
 
136
                name = name + '/'
 
137
            if name in shape:
 
138
                shape.remove(name)
 
139
            else:
 
140
                extras.append(name)
 
141
        if shape:
 
142
            self.fail("expected paths not found in inventory: %r" % shape)
 
143
        if extras:
 
144
            self.fail("unexpected paths found in inventory: %r" % extras)
 
145
 
 
146
 
 
147
    def check_file_contents(self, filename, expect):
 
148
        self.log("check contents of file %s" % filename)
 
149
        contents = file(filename, 'r').read()
 
150
        if contents != expect:
 
151
            self.log("expected: %r" % expected)
 
152
            self.log("actually: %r" % contents)
 
153
            self.fail("contents of %s not as expected")
 
154
            
 
155
 
 
156
 
 
157
class InTempDir(TestBase):
 
158
    """Base class for tests run in a temporary branch."""
 
159
    def setUp(self):
 
160
        import os
 
161
        self.test_dir = os.path.join(self.TEST_ROOT, self.__class__.__name__)
 
162
        os.mkdir(self.test_dir)
 
163
        os.chdir(self.test_dir)
 
164
        
 
165
    def tearDown(self):
 
166
        import os
 
167
        os.chdir(self.TEST_ROOT)
 
168
 
 
169
 
 
170
 
 
171
 
 
172
 
 
173
class _MyResult(TestResult):
 
174
    """
 
175
    Custom TestResult.
 
176
 
 
177
    No special behaviour for now.
 
178
    """
 
179
    def __init__(self, out):
 
180
        self.out = out
 
181
        TestResult.__init__(self)
 
182
 
 
183
    def startTest(self, test):
 
184
        # TODO: Maybe show test.shortDescription somewhere?
 
185
        print >>self.out, '%-60.60s' % test.id(),
 
186
        self.out.flush()
 
187
        TestResult.startTest(self, test)
 
188
 
 
189
    def stopTest(self, test):
 
190
        # print
 
191
        TestResult.stopTest(self, test)
 
192
 
 
193
 
 
194
    def addError(self, test, err):
 
195
        print >>self.out, 'ERROR'
 
196
        TestResult.addError(self, test, err)
 
197
        _show_test_failure('error', test, err, self.out)
 
198
 
 
199
    def addFailure(self, test, err):
 
200
        print >>self.out, 'FAILURE'
 
201
        TestResult.addFailure(self, test, err)
 
202
        _show_test_failure('failure', test, err, self.out)
 
203
 
 
204
    def addSuccess(self, test):
 
205
        print >>self.out, 'OK'
 
206
        TestResult.addSuccess(self, test)
 
207
 
 
208
 
22
209
 
23
210
def selftest():
24
211
    from unittest import TestLoader, TestSuite
25
 
    import bzrlib, bzrlib.store, bzrlib.inventory, bzrlib.branch
26
 
    import bzrlib.osutils, bzrlib.commands, bzrlib.merge3, bzrlib.plugin
27
 
    global MODULES_TO_TEST, MODULES_TO_DOCTEST
 
212
    import bzrlib, bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, bzrlib.commands
28
213
 
29
214
    import bzrlib.selftest.whitebox
30
215
    import bzrlib.selftest.blackbox
31
216
    import bzrlib.selftest.versioning
32
217
    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
218
    import bzrlib.merge_core
39
219
    from doctest import DocTestSuite
40
220
    import os
41
221
    import shutil
42
222
    import time
43
223
    import sys
44
 
    import unittest
45
 
 
46
 
    for m in (bzrlib.store, bzrlib.inventory, bzrlib.branch,
47
 
              bzrlib.osutils, bzrlib.commands, bzrlib.merge3):
48
 
        if m not in MODULES_TO_DOCTEST:
49
 
            MODULES_TO_DOCTEST.append(m)
50
 
            
51
 
    for m in (bzrlib.selftest.whitebox,
52
 
              bzrlib.selftest.versioning,
53
 
              bzrlib.selftest.testinv,
54
 
              bzrlib.selftest.testmerge3,
55
 
              bzrlib.selftest.testhashcache,
56
 
              bzrlib.selftest.teststatus,
57
 
              bzrlib.selftest.blackbox,
58
 
              bzrlib.selftest.testhashcache,
59
 
              bzrlib.selftest.testrevisionnamespaces,
60
 
              bzrlib.selftest.testbranch,
61
 
              ):
62
 
        if m not in MODULES_TO_TEST:
63
 
            MODULES_TO_TEST.append(m)
64
 
 
65
224
 
66
225
    TestBase.BZRPATH = os.path.join(os.path.realpath(os.path.dirname(bzrlib.__path__[0])), 'bzr')
67
226
    print '%-30s %s' % ('bzr binary', TestBase.BZRPATH)
68
227
 
 
228
    _setup_test_log()
 
229
    _setup_test_dir()
69
230
    print
70
231
 
71
232
    suite = TestSuite()
 
233
    tl = TestLoader()
72
234
 
73
235
    # should also test bzrlib.merge_core, but they seem to be out of date with
74
236
    # the code.
75
237
 
76
 
 
77
 
    # XXX: python2.3's TestLoader() doesn't seem to find all the
78
 
    # tests; don't know why
79
 
    for m in MODULES_TO_TEST:
80
 
         suite.addTest(TestLoader().loadTestsFromModule(m))
81
 
 
82
 
    for m in (MODULES_TO_DOCTEST):
 
238
    for m in bzrlib.selftest.whitebox, \
 
239
            bzrlib.selftest.versioning, \
 
240
            bzrlib.selftest.testmerge3:
 
241
        suite.addTest(tl.loadTestsFromModule(m))
 
242
 
 
243
    for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
 
244
            bzrlib.commands, \
 
245
            bzrlib.merge3:
83
246
        suite.addTest(DocTestSuite(m))
84
247
 
85
 
    for p in bzrlib.plugin.all_plugins:
86
 
        if hasattr(p, 'test_suite'):
87
 
            suite.addTest(p.test_suite())
88
 
 
89
 
    suite.addTest(unittest.makeSuite(bzrlib.merge_core.MergeTest, 'test_'))
90
 
 
91
 
    return run_suite(suite, 'testbzr')
92
 
 
93
 
 
 
248
    suite.addTest(bzrlib.selftest.blackbox.suite())
 
249
 
 
250
    # save stdout & stderr so there's no leakage from code-under-test
 
251
    real_stdout = sys.stdout
 
252
    real_stderr = sys.stderr
 
253
    sys.stdout = sys.stderr = TestBase.TEST_LOG
 
254
    try:
 
255
        result = _MyResult(real_stdout)
 
256
        suite.run(result)
 
257
    finally:
 
258
        sys.stdout = real_stdout
 
259
        sys.stderr = real_stderr
 
260
 
 
261
    _show_results(result)
 
262
 
 
263
    return result.wasSuccessful()
 
264
 
 
265
 
 
266
 
 
267
 
 
268
def _setup_test_log():
 
269
    import time
 
270
    import os
 
271
    
 
272
    log_filename = os.path.abspath('testbzr.log')
 
273
    TestBase.TEST_LOG = open(log_filename, 'wt', buffering=1) # line buffered
 
274
 
 
275
    print >>TestBase.TEST_LOG, "bzr tests run at " + time.ctime()
 
276
    print '%-30s %s' % ('test log', log_filename)
 
277
 
 
278
 
 
279
def _setup_test_dir():
 
280
    import os
 
281
    import shutil
 
282
    
 
283
    TestBase.ORIG_DIR = os.getcwdu()
 
284
    TestBase.TEST_ROOT = os.path.abspath("testbzr.tmp")
 
285
 
 
286
    print '%-30s %s' % ('running tests in', TestBase.TEST_ROOT)
 
287
 
 
288
    if os.path.exists(TestBase.TEST_ROOT):
 
289
        shutil.rmtree(TestBase.TEST_ROOT)
 
290
    os.mkdir(TestBase.TEST_ROOT)
 
291
    os.chdir(TestBase.TEST_ROOT)
 
292
 
 
293
    # make a fake bzr directory there to prevent any tests propagating
 
294
    # up onto the source directory's real branch
 
295
    os.mkdir(os.path.join(TestBase.TEST_ROOT, '.bzr'))
 
296
 
 
297
    
 
298
 
 
299
def _show_results(result):
 
300
     print
 
301
     print '%4d tests run' % result.testsRun
 
302
     print '%4d errors' % len(result.errors)
 
303
     print '%4d failures' % len(result.failures)
 
304
 
 
305
 
 
306
 
 
307
def _show_test_failure(kind, case, exc_info, out):
 
308
    from traceback import print_exception
 
309
    
 
310
    print >>out, '-' * 60
 
311
    print >>out, case
 
312
    
 
313
    desc = case.shortDescription()
 
314
    if desc:
 
315
        print >>out, '   (%s)' % desc
 
316
         
 
317
    print_exception(exc_info[0], exc_info[1], exc_info[2], None, out)
 
318
        
 
319
    if isinstance(case, TestBase):
 
320
        print >>out
 
321
        print >>out, 'log from this test:'
 
322
        print >>out, case._log_buf
 
323
         
 
324
    print >>out, '-' * 60
 
325
    
94
326