~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to doc/developers/testing.txt

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

Show diffs side-by-side

added added

removed removed

Lines of Context:
39
39
Running the Test Suite
40
40
======================
41
41
 
42
 
As of Bazaar 2.1, you must have the testtools_ library installed to run
43
 
the bzr test suite.
44
 
 
45
 
.. _testtools: https://launchpad.net/testtools/
46
 
 
47
 
To test all of Bazaar, just run::
48
 
 
49
 
  bzr selftest 
50
 
 
51
 
With ``--verbose`` bzr will print the name of every test as it is run.
52
 
 
53
 
This should always pass, whether run from a source tree or an installed
54
 
copy of Bazaar.  Please investigate and/or report any failures.
55
 
 
56
 
 
57
 
Running particular tests
58
 
------------------------
59
 
 
60
42
Currently, bzr selftest is used to invoke tests.
61
43
You can provide a pattern argument to run a subset. For example,
62
44
to run just the blackbox tests, run::
104
86
--load-list. The later is rarely used but allows to run a subset of a list of
105
87
failing tests for example.
106
88
 
107
 
Disabling plugins
108
 
-----------------
109
 
 
110
 
To test only the bzr core, ignoring any plugins you may have installed,
111
 
use::
112
 
 
113
 
  ./bzr --no-plugins selftest 
114
 
 
115
 
Disabling crash reporting
116
 
-------------------------
117
 
 
118
 
By default Bazaar uses apport_ to report program crashes.  In developing
119
 
Bazaar it's normal and expected to have it crash from time to time, at
120
 
least because a test failed if for no other reason.
121
 
 
122
 
Therefore you should probably add ``debug_flags = no_apport`` to your
123
 
``bazaar.conf`` file (in ``~/.bazaar/`` on Unix), so that failures just
124
 
print a traceback rather than writing a crash file.
125
 
 
126
 
.. _apport: https://launchpad.net/apport/
127
 
 
128
89
 
129
90
Test suite debug flags
130
91
----------------------
136
97
  This can provide useful logging to help debug test failures when used
137
98
  with e.g. ``bzr -Dhpss selftest -E=allow_debug``
138
99
 
139
 
  Note that this will probably cause some tests to fail, because they
140
 
  don't expect to run with any debug flags on.
141
 
 
142
 
 
143
 
Using subunit
144
 
-------------
145
 
 
146
 
Bazaar can optionally produce output in the machine-readable subunit_
147
 
format, so that test output can be post-processed by various tools. To
148
 
generate a subunit test stream::
149
 
 
150
 
 $ ./bzr selftest --subunit
151
 
 
152
 
Processing such a stream can be done using a variety of tools including:
153
 
 
154
 
* The builtin ``subunit2pyunit``, ``subunit-filter``, ``subunit-ls``,
155
 
  ``subunit2junitxml`` from the subunit project.
156
 
 
157
 
* tribunal_, a GUI for showing test results.
158
 
 
159
 
* testrepository_, a tool for gathering and managing test runs.
160
 
 
161
 
.. _subunit: https://launchpad.net/subunit/
162
 
.. _tribunal: https://launchpad.net/tribunal/
163
 
 
164
 
 
165
 
Using testrepository
166
 
--------------------
167
 
 
168
 
Bazaar ships with a config file for testrepository_. This can be very
169
 
useful for keeping track of failing tests and doing general workflow
170
 
support. To run tests using testrepository::
171
 
 
172
 
  $ testr run
173
 
 
174
 
To run only failing tests::
175
 
 
176
 
  $ testr run --failing
177
 
 
178
 
To run only some tests, without plugins::
179
 
 
180
 
  $ test run test_selftest -- --no-plugins
181
 
 
182
 
See the testrepository documentation for more details.
183
 
 
184
 
.. _testrepository: https://launchpad.net/testrepository
185
100
 
186
101
Writing Tests
187
102
=============
188
103
 
189
 
Normally you should add or update a test for all bug fixes or new features
190
 
in Bazaar.
191
 
 
192
 
 
193
104
Where should I put a new test?
194
105
------------------------------
195
106
 
401
312
        ''')
402
313
 
403
314
 
404
 
Import tariff tests
405
 
-------------------
406
 
 
407
 
`bzrlib.tests.test_import_tariff` has some tests that measure how many
408
 
Python modules are loaded to run some representative commands.
409
 
 
410
 
We want to avoid loading code unnecessarily, for reasons including:
411
 
 
412
 
* Python modules are interpreted when they're loaded, either to define
413
 
  classes or modules or perhaps to initialize some structures.
414
 
 
415
 
* With a cold cache we may incur blocking real disk IO for each module.
416
 
 
417
 
* Some modules depend on many others.
418
 
 
419
 
* Some optional modules such as `testtools` are meant to be soft
420
 
  dependencies and only needed for particular cases.  If they're loaded in
421
 
  other cases then bzr may break for people who don't have those modules.
422
 
  
423
 
`test_import_tarrif` allows us to check that removal of imports doesn't
424
 
regress.
425
 
 
426
 
This is done by running the command in a subprocess with
427
 
``--profile-imports``.  Starting a whole Python interpreter is pretty
428
 
slow, so we don't want exhaustive testing here, but just enough to guard
429
 
against distinct fixed problems.
430
 
 
431
 
Assertions about precisely what is loaded tend to be brittle so we instead
432
 
make assertions that particular things aren't loaded.
433
 
 
434
 
Unless selftest is run with ``--no-plugins``, modules will be loaded in
435
 
the usual way and checks made on what they cause to be loaded.  This is
436
 
probably worth checking into, because many bzr users have at least some
437
 
plugins installed (and they're included in binary installers).
438
 
 
439
 
In theory, plugins might have a good reason to load almost anything:
440
 
someone might write a plugin that opens a network connection or pops up a
441
 
gui window every time you run 'bzr status'.  However, it's more likely
442
 
that the code to do these things is just being loaded accidentally.  We
443
 
might eventually need to have a way to make exceptions for particular
444
 
plugins.
445
 
 
446
 
Some things to check:
447
 
 
448
 
* non-GUI commands shouldn't load GUI libraries
449
 
 
450
 
* operations on bzr native formats sholudn't load foreign branch libraries
451
 
 
452
 
* network code shouldn't be loaded for purely local operations
453
 
 
454
 
* particularly expensive Python built-in modules shouldn't be loaded
455
 
  unless there is a good reason
456
 
 
457
 
 
458
 
Testing locking behaviour
459
 
-------------------------
460
 
 
461
 
In order to test the locking behaviour of commands, it is possible to install
462
 
a hook that is called when a write lock is: acquired, released or broken.
463
 
(Read locks also exist, they cannot be discovered in this way.)
464
 
 
465
 
A hook can be installed by calling bzrlib.lock.Lock.hooks.install_named_hook.
466
 
The three valid hooks are: `lock_acquired`, `lock_released` and `lock_broken`.
467
 
 
468
 
Example::
469
 
 
470
 
    locks_acquired = []
471
 
    locks_released = []
472
 
 
473
 
    lock.Lock.hooks.install_named_hook('lock_acquired',
474
 
        locks_acquired.append, None)
475
 
    lock.Lock.hooks.install_named_hook('lock_released',
476
 
        locks_released.append, None)
477
 
 
478
 
`locks_acquired` will now receive a LockResult instance for all locks acquired
479
 
since the time the hook is installed.
480
 
 
481
 
The last part of the `lock_url` allows you to identify the type of object that is locked.
482
 
 
483
 
- BzrDir: `/branch-lock`
484
 
- Working tree: `/checkout/lock`
485
 
- Branch: `/branch/lock`
486
 
- Repository: `/repository/lock`
487
 
 
488
 
To test if a lock is a write lock on a working tree, one can do the following::
489
 
 
490
 
    self.assertEndsWith(locks_acquired[0].lock_url, "/checkout/lock")
491
 
 
492
 
See bzrlib/tests/commands/test_revert.py for an example of how to use this for
493
 
testing locks.
 
315
 
 
316
.. Effort tests
 
317
.. ~~~~~~~~~~~~
 
318
 
494
319
 
495
320
 
496
321
Skipping tests
552
377
        KnownFailure should be used with care as we don't want a
553
378
        proliferation of quietly broken tests.
554
379
 
 
380
ModuleAvailableFeature
 
381
        A helper for handling running tests based on whether a python
 
382
        module is available. This can handle 3rd-party dependencies (is
 
383
        ``paramiko`` available?) as well as stdlib (``termios``) or
 
384
        extension modules (``bzrlib._groupcompress_pyx``). You create a
 
385
        new feature instance with::
 
386
 
 
387
            MyModuleFeature = ModuleAvailableFeature('bzrlib.something')
 
388
 
 
389
            ...
 
390
            def test_something(self):
 
391
                self.requireFeature(MyModuleFeature)
 
392
                something = MyModuleFeature.module
555
393
 
556
394
 
557
395
We plan to support three modes for running the test suite to control the
599
437
 
600
438
    self.requireFeature(StraceFeature)
601
439
 
602
 
The old naming style for features is CamelCase, but because they're
603
 
actually instances not classses they're now given instance-style names
604
 
like ``apport``.
605
 
 
606
 
Features already defined in ``bzrlib.tests`` and ``bzrlib.tests.features``
607
 
include:
608
 
 
609
 
 - apport
610
 
 - paramiko
611
 
 - SymlinkFeature
612
 
 - HardlinkFeature
613
 
 - OsFifoFeature
614
 
 - UnicodeFilenameFeature
615
 
 - FTPServerFeature
 
440
Features already defined in bzrlib.tests include:
 
441
 
 
442
 - SymlinkFeature,
 
443
 - HardlinkFeature,
 
444
 - OsFifoFeature,
 
445
 - UnicodeFilenameFeature,
 
446
 - FTPServerFeature, and
616
447
 - CaseInsensitiveFilesystemFeature.
617
 
 - chown_feature: The test can rely on OS being POSIX and python
618
 
   supporting os.chown.
619
 
 - posix_permissions_feature: The test can use POSIX-style
620
 
   user/group/other permission bits.
621
448
 
622
449
 
623
450
Defining a new feature that tests can require
637
464
 
638
465
    SymlinkFeature = _SymlinkFeature()
639
466
 
640
 
A helper for handling running tests based on whether a python
641
 
module is available. This can handle 3rd-party dependencies (is
642
 
``paramiko`` available?) as well as stdlib (``termios``) or
643
 
extension modules (``bzrlib._groupcompress_pyx``). You create a
644
 
new feature instance with::
645
 
 
646
 
    # in bzrlib/tests/features.py
647
 
    apport = tests.ModuleAvailableFeature('apport')
648
 
 
649
 
 
650
 
    # then in bzrlib/tests/test_apport.py
651
 
    class TestApportReporting(TestCaseInTempDir):
652
 
 
653
 
        _test_needs_features = [features.apport]
654
 
 
655
467
 
656
468
Testing exceptions and errors
657
469
-----------------------------