| Status: | Merged |
|---|---|
| Merged at revision: | not available |
| Proposed branch: | lp:~lifeless/bzr/subunit |
| Merge into: | lp:bzr |
| Diff against target: |
1365 lines (+225/-497) 18 files modified
NEWS (+12/-0) bzrlib/osutils.py (+15/-0) bzrlib/tests/TestUtil.py (+12/-0) bzrlib/tests/__init__.py (+98/-283) bzrlib/tests/blackbox/test_debug.py (+1/-2) bzrlib/tests/blackbox/test_exceptions.py (+1/-2) bzrlib/tests/per_pack_repository.py (+3/-3) bzrlib/tests/per_repository/test_check.py (+5/-8) bzrlib/tests/per_repository/test_check_reconcile.py (+2/-3) bzrlib/tests/per_repository_reference/test_check.py (+1/-2) bzrlib/tests/test_cleanup.py (+2/-4) bzrlib/tests/test_config.py (+2/-2) bzrlib/tests/test_http_response.py (+1/-2) bzrlib/tests/test_merge.py (+3/-4) bzrlib/tests/test_remote.py (+2/-3) bzrlib/tests/test_selftest.py (+46/-165) bzrlib/tests/test_trace.py (+16/-10) bzrlib/tests/test_transport_log.py (+3/-4) |
| To merge this branch: | bzr merge lp:~lifeless/bzr/subunit |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Martin Packman (community) | Abstain | ||
| Vincent Ladeuil | Needs Fixing | ||
| Martin Pool | Needs Fixing | ||
|
Review via email:
|
|||
Commit message
Description of the change
| Robert Collins (lifeless) wrote : | # |
| Martin Pool (mbp) wrote : | # |
2009/12/6 Robert Collins <email address hidden>:
> I'm proposing this branch to get feedback; its not necessarily ripe, though I'd be happy to land it as-is (there aren't any must-do items remaining for it).
Well done.
> === modified file 'NEWS'
> --- NEWS 2009-12-04 22:13:52 +0000
> +++ NEWS 2009-12-06 03:05:32 +0000
> @@ -237,6 +237,10 @@
> Testing
> *******
>
> +* ``bzrlib.
> + This permits features in testtools such as getUniqueInteger and
> + getUniqueString to be used. (Robert Collins)
> +
> * -Dhpssvfs will now trigger on ``RemoteBzrDir.
> more debugging of VFS access triggers. (Robert Collins)
You really need to explicitly mention that testtools is now a
requirement for running the Bazaar test suite, and which version, and
preferably also the URL. It seems like this should also update the
install instructions and maybe setup.py?
Also worth checking that you get a sane message if it's missing.
Since testtools will be changing I'd think about putting in a version
number check after the import.
More later maybe.
--
Martin <http://
| Robert Collins (lifeless) wrote : | # |
I've added some polish and improved the news entry as per Martin's request.
| Martin Packman (gz) wrote : | # |
Doesn't seem as big a code complexity win as I'd hope for adding a whole new dependency.
+traceback.
Not sure monkeypatching a builtin module in the middle of a several thousand line script is a good idea.
| Robert Collins (lifeless) wrote : | # |
On Mon, 2009-12-14 at 21:38 +0000, Martin [gz] wrote:
> Doesn't seem as big a code complexity win as I'd hope for adding a whole new dependency.
How big is big enough ?
> +traceback.
>
> Not sure monkeypatching a builtin module in the middle of a several thousand line script is a good idea.
Sadly, python 2.x is broken in this regard: __str__ on an exception with
a (a_str,) as its args, does an implicit decode of the string. We work
around this in bzrlib.errors by subclassing exception and reimplementing
__str__, but we can't do that for all errors that may be raised by
tests.
-Rob
| Robert Collins (lifeless) wrote : | # |
I plan to land this this afternoon or perhaps tomorrow. Testtools 0.9.2 has been released, and the package is in debian. I can upload that to e.g. the bzr beta PPA.
There is a subunit 0.0.3 release as well, which makes --parallel=fork, ec2test and plain --subunit include separate attachments for the log files (but the fallback behaviour in testtools will include those anyway just not structured as such.
| John A Meinel (jameinel) wrote : | # |
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Robert Collins wrote:
> I plan to land this this afternoon or perhaps tomorrow. Testtools 0.9.2 has been released, and the package is in debian. I can upload that to e.g. the bzr beta PPA.
>
> There is a subunit 0.0.3 release as well, which makes --parallel=fork, ec2test and plain --subunit include separate attachments for the log files (but the fallback behaviour in testtools will include those anyway just not structured as such.
Do you have any idea whether this will destroy the win32 test suite? Or
mac, or anything that doesn't have a deb package infrastructure? I
realize you are antsy to move forward, but given I just got win32
running again, I'd rather not have a serious breakdown at this point. (I
expect it to *probably* be ok, if you can get the right packages installed.)
The comments you've received certainly haven't been "this looks good,
let's land it", so I'm a bit surprised you are pushing this hard. Maybe
I'm wrong, but it feels like the conversation hasn't finished yet.
John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://
iEYEARECAAYFAks
GiwAn3Jc9fkaAe2
=tUCZ
-----END PGP SIGNATURE-----
| Gordon Tyler (doxxx) wrote : | # |
After upgrading to the latest testtools and subunit, I'm able to run bzr selftest using this proposed merge. Still waiting for it to finish though.
| Gordon Tyler (doxxx) wrote : | # |
Perhaps I should mention that I'm running this on Vista64 using a 32-bit version of ActivePython 2.6.
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 03:03 +0000, John A Meinel wrote:
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> Robert Collins wrote:
> > I plan to land this this afternoon or perhaps tomorrow. Testtools 0.9.2 has been released, and the package is in debian. I can upload that to e.g. the bzr beta PPA.
> >
> > There is a subunit 0.0.3 release as well, which makes --parallel=fork, ec2test and plain --subunit include separate attachments for the log files (but the fallback behaviour in testtools will include those anyway just not structured as such.
>
> Do you have any idea whether this will destroy the win32 test suite?
Yes, it won't.
> Or
> mac, or anything that doesn't have a deb package infrastructure? I
> realize you are antsy to move forward, but given I just got win32
> running again, I'd rather not have a serious breakdown at this point. (I
> expect it to *probably* be ok, if you can get the right packages installed.)
All you need is python-testtools (available via pypi, easy_install,
launchpad tarball or bzr branch lp:testtools), and python
2.4/2.5/
> The comments you've received certainly haven't been "this looks good,
> let's land it", so I'm a bit surprised you are pushing this hard. Maybe
> I'm wrong, but it feels like the conversation hasn't finished yet.
Martin Pool provided some comments, which I've considered and acted on
most of. He said 'maybe more later', that was 9 days ago; Martin [gz]
said 'not as much benefit as expected', and I've asked how much he
expected.
I have no sense of ongoing discussion about this; its been blocked on
testtools releasing an appropriate release - which it has now, and given
the absence of negative reviews, am planning on exercising the soft
timeout our review process has rather than delaying indefinitely. There
has been discussion on list about the general issue of dependencies, and
the outcome there was 'put it up and we can discuss it' (as I recall) -
which is what I've done. I also recall Martin (Pool) saying somewhere
that he is convinced that testtools has useful features and active
maintainers and he is ok with a dependency on it.
Of course, if you are concerned about it I'll hold off landing it, but
I'd like some articulation of concerns so that I can act on them. This
is important to me because I don't like writing code twice, and bzr's
current unittest structure forces me to do so.
This patch doesn't do any OS specific changes, so its very unlikely to
have an OS specific fallout. Gordon's positive feedback is an indicator
that its probably ok.
-Rob
| Martin Pool (mbp) wrote : | # |
2009/12/16 Robert Collins <email address hidden>:
> Martin Pool provided some comments, which I've considered and acted on
> most of. He said 'maybe more later', that was 9 days ago;
I'm not +1 until I get to read it again - the maybe was whether I
would get to that soon. If other core reviewers approve before I do,
that's great.
--
Martin <http://
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 04:57 +0000, Martin Pool wrote:
> 2009/12/16 Robert Collins <email address hidden>:
> > Martin Pool provided some comments, which I've considered and acted on
> > most of. He said 'maybe more later', that was 9 days ago;
>
> I'm not +1 until I get to read it again - the maybe was whether I
> would get to that soon. If other core reviewers approve before I do,
> that's great.
Given your encouragement to us to not block, do you think 10 days is
'long enough' to land in the absence of negative feedback?
Its not even a particularly large patch - 18 files changed, 210
insertions(+), 412 deletions(-) - so I feel that the lack of a full
review is an indication that its not important in either a risk or
benefits sense to other folk.
As I said to John, I won't land it if folk have concerns, but neither do
I want to block on it simply because folk aren't excited enough to
review it.
-Rob
| Matt Nordhoff (mnordhoff) wrote : | # |
Matt's tiny nitpicks of the day:
25 === modified file 'bzrlib/osutils.py'
42 + if type(object) == str:
Types should be compared with "is".
71 === modified file 'bzrlib/
156 + # pythons this goes sufficiently wrong that it is a bad idea. (
157 + # specifically a built in file with encoding 'UTF-8' will still try
158 + # to encode using ascii.
Where's the ")"? :D
198 +def _clever_
199 + try:
200 + return str(value)
201 + except:
Blanket except? That's scary.
290 + @staticmethod
291 + def _do_known_
299 + @staticmethod
300 def _do_not_
308 + @staticmethod
309 + def _do_unsupported
I should probably read the testtools docs or something, but... Static methods that take "self"?
597 === modified file 'bzrlib/
606 + log = u"".join(
It's a bit unpleasant to have that pasted all over the test suite. Though I guess it isn't duplicated *that* many times, given the number of tests...
| Martin Pool (mbp) wrote : | # |
8 +* New helper osutils.
9 + passes str objects straight through. This is used for selftest but
10 + may be useful for diff and other operations that generate mixed output.
11 + (Robert Collins)
12 +
Please let's not have two things called StreamWriter that behave differently. needsfixing. Something like UnicodeOrBytesT
+ log = u"".join(
Agree with Matt, this is ugly to repeat. Couldn't we have a convenience function for it?
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 06:05 +0000, Matt Nordhoff wrote:
>
> 198 +def _clever_
> 199 + try:
> 200 + return str(value)
> 201 + except:
>
> Blanket except? That's scary.
Look at traceback._some_str :P.
-Rob
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 06:09 +0000, Martin Pool wrote:
> Review: Needs Fixing
> 8 +* New helper osutils.
> 9 + passes str objects straight through. This is used for selftest but
> 10 + may be useful for diff and other operations that generate mixed output.
> 11 + (Robert Collins)
> 12 +
>
> Please let's not have two things called StreamWriter that behave differently. needsfixing. Something like UnicodeOrBytesT
Ok. I had called it StreamWriter because I plan to submit a patch to
python to fix this, as I believe it meets the /intent/ of the python
code more accurately, but I'm happy to rename it for now.
> + log = u"".join(
>
> Agree with Matt, this is ugly to repeat. Couldn't we have a convenience function for it?
Sure, I was intent on getting away from the tricky implementation we
had, but having done so can add back a get_log() happily. I'll do this
tomorrow.
-Rob
| Vincent Ladeuil (vila) wrote : | # |
So. I've tested without subunit nor testtools => clean failure:
bzr: ERROR: No module named testtools
You may need to install this Python library separately.
We may want to polish things a bit on platforms where this may be harder to install, but nothing urgent.
I've tested with my current versions of subunit/testtools, horrible crashes :) The NEWS entry should
take care of that (I don't know how many people are currently using testtools/subunit and running
the test suite but they are likely to read the NEWS).
BUT, running with up-to-date versions is far too verbose for XFAILs, the traceback is nicely presented
thank you, I just don't want to see it when running with --parallel=fork.
I'm +1 for get_log() and renaming StreamWriter until your patch is accepted.
That being said, it's a pleasure to see many warts removed (don't tell me you need BZRTransforming
back to addres the above :0) , thanks for that.
I'll be running this branch on babune and comment later about the results.
| Vincent Ladeuil (vila) wrote : | # |
babune is still running but at least one full test suite has run all tracked OSes (OSX still suspended)
So, there is nothing important to add except that skipped tests are also too verbose:
per_branch.
Text attachment: log
------------
------------
Text attachment: reason
------------
Not a local URL
------------
Hmm, weird, I don't get the same behavior everywhere, some runs handle XFAIL but not SKIP, some handle neither...
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 15:44 +0000, Vincent Ladeuil wrote:
>
> I've tested with my current versions of subunit/testtools, horrible
> crashes :) The NEWS entry should
> take care of that (I don't know how many people are currently using
> testtools/subunit and running
> the test suite but they are likely to read the NEWS).
It would help me when reporting a problem with a patch if you can paste
what it looks like, then I can describe that easily for other people.
> BUT, running with up-to-date versions is far too verbose for XFAILs,
> the traceback is nicely presented
> thank you, I just don't want to see it when running with
> --parallel=fork.
Oh, that was an unintended behavioural change, will fix. It is detecting
it as xfail FWIW.
-Rob
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 20:44 +0000, Vincent Ladeuil wrote:
> babune is still running but at least one full test suite has run all tracked OSes (OSX still suspended)
> So, there is nothing important to add except that skipped tests are also too verbose:
What platform :- ?
./bzr selftest --no-plugins
per_branch.
--parallel=fork
bzr
selftest: /home/robertc/
/home/
bzr-2.1.0dev5 python-2.6.4
Linux-2.
-------
Ran 8 tests in 0.630s
OK
8 tests skipped
| Robert Collins (lifeless) wrote : | # |
On Wed, 2009-12-16 at 21:00 +0000, Robert Collins wrote:
>
> > BUT, running with up-to-date versions is far too verbose for XFAILs,
> > the traceback is nicely presented
> > thank you, I just don't want to see it when running with
> > --parallel=fork.
>
> Oh, that was an unintended behavioural change, will fix. It is
> detecting
> it as xfail FWIW.
Hah! Brilliant!
Read the code for addExpectedFailure
it is *meant* to show the backtrace.
But it doesn't. Why? because it uses ui.ui_factory.note, and during the
execution of a test (which is when the current code reports things with
exceptions), ui.ui_factory is a SilentUIFactory.
Global State, I heart thee.
Oh, I've also been able to delete expectFailure, another helper thats in
the base class I missed.
-Rob
| John A Meinel (jameinel) wrote : | # |
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Robert Collins wrote:
> On Wed, 2009-12-16 at 21:00 +0000, Robert Collins wrote:
>>> BUT, running with up-to-date versions is far too verbose for XFAILs,
>>> the traceback is nicely presented
>>> thank you, I just don't want to see it when running with
>>> --parallel=fork.
>> Oh, that was an unintended behavioural change, will fix. It is
>> detecting
>> it as xfail FWIW.
>
> Hah! Brilliant!
>
> Read the code for addExpectedFailure
>
> it is *meant* to show the backtrace.
>
> But it doesn't. Why? because it uses ui.ui_factory.note, and during the
> execution of a test (which is when the current code reports things with
> exceptions), ui.ui_factory is a SilentUIFactory.
>
> Global State, I heart thee.
>
> Oh, I've also been able to delete expectFailure, another helper thats in
> the base class I missed.
>
>
> -Rob
I'll note that I personally find the expectFailure syntax to be
backwards. At least, IMO, you should have an assert which *succeeds*
which proves that the failure is occurring. Rather than expecting the
assert to fail. Because the latter case means that it can fail for any
reason, and still cause the expectFailure to pass.
But, I guess we have what we have.
John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://
iEYEARECAAYFAks
27QAoKW9xy6Mt+
=ycMf
-----END PGP SIGNATURE-----
| Martin Pool (mbp) wrote : | # |
2009/12/17 John A Meinel <email address hidden>:
> I'll note that I personally find the expectFailure syntax to be
> backwards. At least, IMO, you should have an assert which *succeeds*
> which proves that the failure is occurring. Rather than expecting the
> assert to fail. Because the latter case means that it can fail for any
> reason, and still cause the expectFailure to pass.
>
> But, I guess we have what we have.
I don't mind renaming it or adding an alternative.
What I liked about expectFailure (and I think I added it) is that you
can just add it as a kind of preposition once you have a failing test.
It's true it's less precise.
--
Martin <http://
| Robert Collins (lifeless) wrote : | # |
Its actually pretty precise - it has to raise AssertionError : there are
three possibly behaviours:
- the predicate works -> test failure
- the predicate raises AssertionError -> test pass
- the predicate raises some other exception -> test failure
-Rob
| Martin Packman (gz) wrote : | # |
> Martin [gz]
> said 'not as much benefit as expected', and I've asked how much he
> expected.
Sorry, launchpad seems not to send email if you only comment, so unless I happen to check back I miss things.
> How big is big enough ?
Well, currently when my code that depends on bazaar.tests breaks I have to read a 4500 line file to understand why. With this change, I'll have to read a 4300 line file and a new module I've never looked at before.
> Sadly, python 2.x is broken in this regard:
Sure, but is this really the best place to fix it? And when it's core python being fiddled with you expect at least an upstream bug report linked prominently near the fiddling.
| Robert Collins (lifeless) wrote : | # |
On Thu, 2009-12-17 at 02:17 +0000, Martin [gz] wrote:
> > Martin [gz]
> > said 'not as much benefit as expected', and I've asked how much he
> > expected.
>
> Sorry, launchpad seems not to send email if you only comment, so unless I happen to check back I miss things.
It should be mailing on every review-or-comment.
> > How big is big enough ?
>
> Well, currently when my code that depends on bazaar.tests breaks I have to read a 4500 line file to understand why. With this change, I'll have to read a 4300 line file and a new module I've never looked at before.
>
> > Sadly, python 2.x is broken in this regard:
>
> Sure, but is this really the best place to fix it? And when it's core python being fiddled with you expect at least an upstream bug report linked prominently near the fiddling.
If you have a better place to suggest, I'm happy to do it there.
python2.x won't be fixed in this regard, and 3.0 doesn't have the same
confusion AIUI.
-Rob
| Martin Packman (gz) wrote : | # |
> It should be mailing on every review-or-comment.
Hm, still no email. There's a nice big box on the page saying who's subscribed, and not button saying "add me" either. I'll set the review type this time which should get me cc-ed.
> If you have a better place to suggest, I'm happy to do it there.
Well, as printing exceptions is a testing kind of thing, the new upstream testing package?
Just tried installing the testtools package, it has three failures on Jython and doesn't install on IronPython. Probably shallow, I'll find some time to look into it.
| Matt Nordhoff (mnordhoff) wrote : | # |
Martin [gz] wrote:
> Review: Abstain
>> It should be mailing on every review-or-comment.
>
> Hm, still no email. There's a nice big box on the page saying who's subscribed, and not button saying "add me" either. I'll set the review type this time which should get me cc-ed.
Yer still not on the list. Try subscribing to the source or destination
branch:
<https:/
<https:/
--
Matt Nordhoff
| Robert Collins (lifeless) wrote : | # |
On Thu, 2009-12-17 at 02:47 +0000, Martin [gz] wrote:
> Review: Abstain
> > It should be mailing on every review-or-comment.
>
> Hm, still no email. There's a nice big box on the page saying who's subscribed, and not button saying "add me" either. I'll set the review type this time which should get me cc-ed.
>
> > If you have a better place to suggest, I'm happy to do it there.
>
> Well, as printing exceptions is a testing kind of thing, the new upstream testing package?
Its only needed if you have exceptions that aren't valid [default codec]
- its not something I'd want just importing a regular library package to
do, but I think its ok for an application to do.
> Just tried installing the testtools package, it has three failures on Jython and doesn't install on IronPython. Probably shallow, I'll find some time to look into it.
Please report bugs at launchpad.
them.
-Rob
| Martin Pool (mbp) wrote : | # |
2009/12/17 Martin [gz] <email address hidden>:
> Review: Abstain
>> It should be mailing on every review-or-comment.
>
> Hm, still no email. There's a nice big box on the page saying who's subscribed, and not button saying "add me" either. I'll set the review type this time which should get me cc-ed.
See https:/
--
Martin <http://
| John A Meinel (jameinel) wrote : | # |
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Robert Collins wrote:
> Its actually pretty precise - it has to raise AssertionError : there are
> three possibly behaviours:
> - the predicate works -> test failure
> - the predicate raises AssertionError -> test pass
> - the predicate raises some other exception -> test failure
>
> -Rob
So that is true, except you write the test as 'assertEqual, 20' # fails
Which means that it could be 30, or it could be 100. When it often
should be failing in a known way. I think you can turn it around as
"assertNotEqual, 52". Though I had to think about it for a while, which
shows it isn't just obvious.
John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://
iEYEARECAAYFAks
RmgAoNG44xgHx+
=4Kc+
-----END PGP SIGNATURE-----
Preview Diff
| 1 | === modified file 'NEWS' | |||
| 2 | --- NEWS 2009-12-16 20:01:49 +0000 | |||
| 3 | +++ NEWS 2009-12-17 09:43:14 +0000 | |||
| 4 | @@ -38,9 +38,21 @@ | |||
| 5 | 38 | Internals | 38 | Internals |
| 6 | 39 | ********* | 39 | ********* |
| 7 | 40 | 40 | ||
| 8 | 41 | * New helper osutils.UnicodeOrBytesToBytesWriter which encodes unicode | ||
| 9 | 42 | objects but passes str objects straight through. This is used for | ||
| 10 | 43 | selftest but may be useful for diff and other operations that generate | ||
| 11 | 44 | mixed output. (Robert Collins) | ||
| 12 | 45 | |||
| 13 | 41 | Testing | 46 | Testing |
| 14 | 42 | ******* | 47 | ******* |
| 15 | 43 | 48 | ||
| 16 | 49 | * ``bzrlib.tests.TestCase`` now subclasses ``testtools.testcase.TestCase``. | ||
| 17 | 50 | This permits features in testtools such as getUniqueInteger and | ||
| 18 | 51 | getUniqueString to be used. Because of this, testtools version 0.9.2 or | ||
| 19 | 52 | newer is now a dependency to run bzr selftest. Running with versions of | ||
| 20 | 53 | testtools less than 0.9.2 will cause bzr to error while loading the test | ||
| 21 | 54 | suite. (Robert Collins) | ||
| 22 | 55 | |||
| 23 | 44 | bzr 2.0.4 (not released yet) | 56 | bzr 2.0.4 (not released yet) |
| 24 | 45 | ############################ | 57 | ############################ |
| 25 | 46 | 58 | ||
| 26 | 47 | 59 | ||
| 27 | === modified file 'bzrlib/osutils.py' | |||
| 28 | --- bzrlib/osutils.py 2009-12-16 10:54:55 +0000 | |||
| 29 | +++ bzrlib/osutils.py 2009-12-17 09:43:14 +0000 | |||
| 30 | @@ -2087,3 +2087,18 @@ | |||
| 31 | 2087 | if use_cache: | 2087 | if use_cache: |
| 32 | 2088 | _cached_concurrency = concurrency | 2088 | _cached_concurrency = concurrency |
| 33 | 2089 | return concurrency | 2089 | return concurrency |
| 34 | 2090 | |||
| 35 | 2091 | |||
| 36 | 2092 | class UnicodeOrBytesToBytesWriter(codecs.StreamWriter): | ||
| 37 | 2093 | """A stream writer that doesn't decode str arguments.""" | ||
| 38 | 2094 | |||
| 39 | 2095 | def __init__(self, codec, stream, errors='strict'): | ||
| 40 | 2096 | codecs.StreamWriter.__init__(self, stream, errors) | ||
| 41 | 2097 | self.encode = codec.encode | ||
| 42 | 2098 | |||
| 43 | 2099 | def write(self, object): | ||
| 44 | 2100 | if type(object) is str: | ||
| 45 | 2101 | self.stream.write(object) | ||
| 46 | 2102 | else: | ||
| 47 | 2103 | data, _ = self.encode(object, self.errors) | ||
| 48 | 2104 | self.stream.write(data) | ||
| 49 | 2090 | 2105 | ||
| 50 | === modified file 'bzrlib/tests/TestUtil.py' | |||
| 51 | --- bzrlib/tests/TestUtil.py 2009-03-23 14:59:43 +0000 | |||
| 52 | +++ bzrlib/tests/TestUtil.py 2009-12-17 09:43:14 +0000 | |||
| 53 | @@ -72,6 +72,18 @@ | |||
| 54 | 72 | visitor.visitSuite(self) | 72 | visitor.visitSuite(self) |
| 55 | 73 | visitTests(self, visitor) | 73 | visitTests(self, visitor) |
| 56 | 74 | 74 | ||
| 57 | 75 | def run(self, result): | ||
| 58 | 76 | """Run the tests in the suite, discarding references after running.""" | ||
| 59 | 77 | tests = list(self) | ||
| 60 | 78 | tests.reverse() | ||
| 61 | 79 | self._tests = [] | ||
| 62 | 80 | while tests: | ||
| 63 | 81 | if result.shouldStop: | ||
| 64 | 82 | self._tests = reversed(tests) | ||
| 65 | 83 | break | ||
| 66 | 84 | tests.pop().run(result) | ||
| 67 | 85 | return result | ||
| 68 | 86 | |||
| 69 | 75 | 87 | ||
| 70 | 76 | class TestLoader(unittest.TestLoader): | 88 | class TestLoader(unittest.TestLoader): |
| 71 | 77 | """Custom TestLoader to extend the stock python one.""" | 89 | """Custom TestLoader to extend the stock python one.""" |
| 72 | 78 | 90 | ||
| 73 | === modified file 'bzrlib/tests/__init__.py' | |||
| 74 | --- bzrlib/tests/__init__.py 2009-12-08 21:46:07 +0000 | |||
| 75 | +++ bzrlib/tests/__init__.py 2009-12-17 09:43:14 +0000 | |||
| 76 | @@ -46,9 +46,12 @@ | |||
| 77 | 46 | import tempfile | 46 | import tempfile |
| 78 | 47 | import threading | 47 | import threading |
| 79 | 48 | import time | 48 | import time |
| 80 | 49 | import traceback | ||
| 81 | 49 | import unittest | 50 | import unittest |
| 82 | 50 | import warnings | 51 | import warnings |
| 83 | 51 | 52 | ||
| 84 | 53 | import testtools | ||
| 85 | 54 | from testtools import content | ||
| 86 | 52 | 55 | ||
| 87 | 53 | from bzrlib import ( | 56 | from bzrlib import ( |
| 88 | 54 | branchbuilder, | 57 | branchbuilder, |
| 89 | @@ -228,8 +231,10 @@ | |||
| 90 | 228 | '%d non-main threads were left active in the end.\n' | 231 | '%d non-main threads were left active in the end.\n' |
| 91 | 229 | % (TestCase._active_threads - 1)) | 232 | % (TestCase._active_threads - 1)) |
| 92 | 230 | 233 | ||
| 94 | 231 | def _extractBenchmarkTime(self, testCase): | 234 | def _extractBenchmarkTime(self, testCase, details=None): |
| 95 | 232 | """Add a benchmark time for the current test case.""" | 235 | """Add a benchmark time for the current test case.""" |
| 96 | 236 | if details and 'benchtime' in details: | ||
| 97 | 237 | return float(''.join(details['benchtime'].iter_bytes())) | ||
| 98 | 233 | return getattr(testCase, "_benchtime", None) | 238 | return getattr(testCase, "_benchtime", None) |
| 99 | 234 | 239 | ||
| 100 | 235 | def _elapsedTestTimeString(self): | 240 | def _elapsedTestTimeString(self): |
| 101 | @@ -269,7 +274,7 @@ | |||
| 102 | 269 | else: | 274 | else: |
| 103 | 270 | bzr_path = sys.executable | 275 | bzr_path = sys.executable |
| 104 | 271 | self.stream.write( | 276 | self.stream.write( |
| 106 | 272 | 'testing: %s\n' % (bzr_path,)) | 277 | 'bzr selftest: %s\n' % (bzr_path,)) |
| 107 | 273 | self.stream.write( | 278 | self.stream.write( |
| 108 | 274 | ' %s\n' % ( | 279 | ' %s\n' % ( |
| 109 | 275 | bzrlib.__path__[0],)) | 280 | bzrlib.__path__[0],)) |
| 110 | @@ -320,13 +325,13 @@ | |||
| 111 | 320 | self.stop() | 325 | self.stop() |
| 112 | 321 | self._cleanupLogFile(test) | 326 | self._cleanupLogFile(test) |
| 113 | 322 | 327 | ||
| 115 | 323 | def addSuccess(self, test): | 328 | def addSuccess(self, test, details=None): |
| 116 | 324 | """Tell result that test completed successfully. | 329 | """Tell result that test completed successfully. |
| 117 | 325 | 330 | ||
| 118 | 326 | Called from the TestCase run() | 331 | Called from the TestCase run() |
| 119 | 327 | """ | 332 | """ |
| 120 | 328 | if self._bench_history is not None: | 333 | if self._bench_history is not None: |
| 122 | 329 | benchmark_time = self._extractBenchmarkTime(test) | 334 | benchmark_time = self._extractBenchmarkTime(test, details) |
| 123 | 330 | if benchmark_time is not None: | 335 | if benchmark_time is not None: |
| 124 | 331 | self._bench_history.write("%s %s\n" % ( | 336 | self._bench_history.write("%s %s\n" % ( |
| 125 | 332 | self._formatTime(benchmark_time), | 337 | self._formatTime(benchmark_time), |
| 126 | @@ -362,26 +367,6 @@ | |||
| 127 | 362 | self.not_applicable_count += 1 | 367 | self.not_applicable_count += 1 |
| 128 | 363 | self.report_not_applicable(test, reason) | 368 | self.report_not_applicable(test, reason) |
| 129 | 364 | 369 | ||
| 130 | 365 | def printErrorList(self, flavour, errors): | ||
| 131 | 366 | for test, err in errors: | ||
| 132 | 367 | self.stream.writeln(self.separator1) | ||
| 133 | 368 | self.stream.write("%s: " % flavour) | ||
| 134 | 369 | self.stream.writeln(self.getDescription(test)) | ||
| 135 | 370 | if getattr(test, '_get_log', None) is not None: | ||
| 136 | 371 | log_contents = test._get_log() | ||
| 137 | 372 | if log_contents: | ||
| 138 | 373 | self.stream.write('\n') | ||
| 139 | 374 | self.stream.write( | ||
| 140 | 375 | ('vvvv[log from %s]' % test.id()).ljust(78,'-')) | ||
| 141 | 376 | self.stream.write('\n') | ||
| 142 | 377 | self.stream.write(log_contents) | ||
| 143 | 378 | self.stream.write('\n') | ||
| 144 | 379 | self.stream.write( | ||
| 145 | 380 | ('^^^^[log from %s]' % test.id()).ljust(78,'-')) | ||
| 146 | 381 | self.stream.write('\n') | ||
| 147 | 382 | self.stream.writeln(self.separator2) | ||
| 148 | 383 | self.stream.writeln("%s" % err) | ||
| 149 | 384 | |||
| 150 | 385 | def _post_mortem(self): | 370 | def _post_mortem(self): |
| 151 | 386 | """Start a PDB post mortem session.""" | 371 | """Start a PDB post mortem session.""" |
| 152 | 387 | if os.environ.get('BZR_TEST_PDB', None): | 372 | if os.environ.get('BZR_TEST_PDB', None): |
| 153 | @@ -499,8 +484,7 @@ | |||
| 154 | 499 | )) | 484 | )) |
| 155 | 500 | 485 | ||
| 156 | 501 | def report_known_failure(self, test, err): | 486 | def report_known_failure(self, test, err): |
| 159 | 502 | ui.ui_factory.note('XFAIL: %s\n%s\n' % ( | 487 | pass |
| 158 | 503 | self._test_description(test), err[1])) | ||
| 160 | 504 | 488 | ||
| 161 | 505 | def report_skip(self, test, reason): | 489 | def report_skip(self, test, reason): |
| 162 | 506 | pass | 490 | pass |
| 163 | @@ -604,6 +588,14 @@ | |||
| 164 | 604 | applied left to right - the first element in the list is the | 588 | applied left to right - the first element in the list is the |
| 165 | 605 | innermost decorator. | 589 | innermost decorator. |
| 166 | 606 | """ | 590 | """ |
| 167 | 591 | # stream may know claim to know to write unicode strings, but in older | ||
| 168 | 592 | # pythons this goes sufficiently wrong that it is a bad idea. ( | ||
| 169 | 593 | # specifically a built in file with encoding 'UTF-8' will still try | ||
| 170 | 594 | # to encode using ascii. | ||
| 171 | 595 | new_encoding = osutils.get_terminal_encoding() | ||
| 172 | 596 | codec = codecs.lookup(new_encoding) | ||
| 173 | 597 | stream = osutils.UnicodeOrBytesToBytesWriter(codec, stream) | ||
| 174 | 598 | stream.encoding = new_encoding | ||
| 175 | 607 | self.stream = unittest._WritelnDecorator(stream) | 599 | self.stream = unittest._WritelnDecorator(stream) |
| 176 | 608 | self.descriptions = descriptions | 600 | self.descriptions = descriptions |
| 177 | 609 | self.verbosity = verbosity | 601 | self.verbosity = verbosity |
| 178 | @@ -629,14 +621,6 @@ | |||
| 179 | 629 | for decorator in self._result_decorators: | 621 | for decorator in self._result_decorators: |
| 180 | 630 | result = decorator(result) | 622 | result = decorator(result) |
| 181 | 631 | result.stop_early = self.stop_on_failure | 623 | result.stop_early = self.stop_on_failure |
| 182 | 632 | try: | ||
| 183 | 633 | import testtools | ||
| 184 | 634 | except ImportError: | ||
| 185 | 635 | pass | ||
| 186 | 636 | else: | ||
| 187 | 637 | if isinstance(test, testtools.ConcurrentTestSuite): | ||
| 188 | 638 | # We need to catch bzr specific behaviors | ||
| 189 | 639 | result = BZRTransformingResult(result) | ||
| 190 | 640 | result.startTestRun() | 624 | result.startTestRun() |
| 191 | 641 | try: | 625 | try: |
| 192 | 642 | test.run(result) | 626 | test.run(result) |
| 193 | @@ -660,8 +644,7 @@ | |||
| 194 | 660 | % (type(suite), suite)) | 644 | % (type(suite), suite)) |
| 195 | 661 | 645 | ||
| 196 | 662 | 646 | ||
| 199 | 663 | class TestSkipped(Exception): | 647 | TestSkipped = testtools.testcase.TestSkipped |
| 198 | 664 | """Indicates that a test was intentionally skipped, rather than failing.""" | ||
| 200 | 665 | 648 | ||
| 201 | 666 | 649 | ||
| 202 | 667 | class TestNotApplicable(TestSkipped): | 650 | class TestNotApplicable(TestSkipped): |
| 203 | @@ -673,14 +656,23 @@ | |||
| 204 | 673 | """ | 656 | """ |
| 205 | 674 | 657 | ||
| 206 | 675 | 658 | ||
| 215 | 676 | class KnownFailure(AssertionError): | 659 | # traceback._some_str fails to format exceptions that have the default |
| 216 | 677 | """Indicates that a test failed in a precisely expected manner. | 660 | # __str__ which does an implicit ascii conversion. However, repr() on those |
| 217 | 678 | 661 | # objects works, for all that its not quite what the doctor may have ordered. | |
| 218 | 679 | Such failures dont block the whole test suite from passing because they are | 662 | def _clever_some_str(value): |
| 219 | 680 | indicators of partially completed code or of future work. We have an | 663 | try: |
| 220 | 681 | explicit error for them so that we can ensure that they are always visible: | 664 | return str(value) |
| 221 | 682 | KnownFailures are always shown in the output of bzr selftest. | 665 | except: |
| 222 | 683 | """ | 666 | try: |
| 223 | 667 | return repr(value).replace('\\n', '\n') | ||
| 224 | 668 | except: | ||
| 225 | 669 | return '<unprintable %s object>' % type(value).__name__ | ||
| 226 | 670 | |||
| 227 | 671 | traceback._some_str = _clever_some_str | ||
| 228 | 672 | |||
| 229 | 673 | |||
| 230 | 674 | # deprecated - use self.knownFailure(), or self.expectFailure. | ||
| 231 | 675 | KnownFailure = testtools.testcase._ExpectedFailure | ||
| 232 | 684 | 676 | ||
| 233 | 685 | 677 | ||
| 234 | 686 | class UnavailableFeature(Exception): | 678 | class UnavailableFeature(Exception): |
| 235 | @@ -762,7 +754,7 @@ | |||
| 236 | 762 | return NullProgressView() | 754 | return NullProgressView() |
| 237 | 763 | 755 | ||
| 238 | 764 | 756 | ||
| 240 | 765 | class TestCase(unittest.TestCase): | 757 | class TestCase(testtools.TestCase): |
| 241 | 766 | """Base class for bzr unit tests. | 758 | """Base class for bzr unit tests. |
| 242 | 767 | 759 | ||
| 243 | 768 | Tests that need access to disk resources should subclass | 760 | Tests that need access to disk resources should subclass |
| 244 | @@ -787,24 +779,26 @@ | |||
| 245 | 787 | _leaking_threads_tests = 0 | 779 | _leaking_threads_tests = 0 |
| 246 | 788 | _first_thread_leaker_id = None | 780 | _first_thread_leaker_id = None |
| 247 | 789 | _log_file_name = None | 781 | _log_file_name = None |
| 248 | 790 | _log_contents = '' | ||
| 249 | 791 | _keep_log_file = False | ||
| 250 | 792 | # record lsprof data when performing benchmark calls. | 782 | # record lsprof data when performing benchmark calls. |
| 251 | 793 | _gather_lsprof_in_benchmarks = False | 783 | _gather_lsprof_in_benchmarks = False |
| 252 | 794 | attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc', | ||
| 253 | 795 | '_log_contents', '_log_file_name', '_benchtime', | ||
| 254 | 796 | '_TestCase__testMethodName', '_TestCase__testMethodDoc',) | ||
| 255 | 797 | 784 | ||
| 256 | 798 | def __init__(self, methodName='testMethod'): | 785 | def __init__(self, methodName='testMethod'): |
| 257 | 799 | super(TestCase, self).__init__(methodName) | 786 | super(TestCase, self).__init__(methodName) |
| 258 | 800 | self._cleanups = [] | 787 | self._cleanups = [] |
| 259 | 801 | self._bzr_test_setUp_run = False | ||
| 260 | 802 | self._bzr_test_tearDown_run = False | ||
| 261 | 803 | self._directory_isolation = True | 788 | self._directory_isolation = True |
| 262 | 789 | self.exception_handlers.insert(0, | ||
| 263 | 790 | (UnavailableFeature, self._do_unsupported_or_skip)) | ||
| 264 | 791 | self.exception_handlers.insert(0, | ||
| 265 | 792 | (TestNotApplicable, self._do_not_applicable)) | ||
| 266 | 804 | 793 | ||
| 267 | 805 | def setUp(self): | 794 | def setUp(self): |
| 270 | 806 | unittest.TestCase.setUp(self) | 795 | super(TestCase, self).setUp() |
| 271 | 807 | self._bzr_test_setUp_run = True | 796 | for feature in getattr(self, '_test_needs_features', []): |
| 272 | 797 | self.requireFeature(feature) | ||
| 273 | 798 | self._log_contents = None | ||
| 274 | 799 | self.addDetail("log", content.Content(content.ContentType("text", | ||
| 275 | 800 | "plain", {"charset": "utf8"}), | ||
| 276 | 801 | lambda:[self._get_log(keep_log_file=True)])) | ||
| 277 | 808 | self._cleanEnvironment() | 802 | self._cleanEnvironment() |
| 278 | 809 | self._silenceUI() | 803 | self._silenceUI() |
| 279 | 810 | self._startLogFile() | 804 | self._startLogFile() |
| 280 | @@ -1289,41 +1283,6 @@ | |||
| 281 | 1289 | m += ": " + msg | 1283 | m += ": " + msg |
| 282 | 1290 | self.fail(m) | 1284 | self.fail(m) |
| 283 | 1291 | 1285 | ||
| 284 | 1292 | def expectFailure(self, reason, assertion, *args, **kwargs): | ||
| 285 | 1293 | """Invoke a test, expecting it to fail for the given reason. | ||
| 286 | 1294 | |||
| 287 | 1295 | This is for assertions that ought to succeed, but currently fail. | ||
| 288 | 1296 | (The failure is *expected* but not *wanted*.) Please be very precise | ||
| 289 | 1297 | about the failure you're expecting. If a new bug is introduced, | ||
| 290 | 1298 | AssertionError should be raised, not KnownFailure. | ||
| 291 | 1299 | |||
| 292 | 1300 | Frequently, expectFailure should be followed by an opposite assertion. | ||
| 293 | 1301 | See example below. | ||
| 294 | 1302 | |||
| 295 | 1303 | Intended to be used with a callable that raises AssertionError as the | ||
| 296 | 1304 | 'assertion' parameter. args and kwargs are passed to the 'assertion'. | ||
| 297 | 1305 | |||
| 298 | 1306 | Raises KnownFailure if the test fails. Raises AssertionError if the | ||
| 299 | 1307 | test succeeds. | ||
| 300 | 1308 | |||
| 301 | 1309 | example usage:: | ||
| 302 | 1310 | |||
| 303 | 1311 | self.expectFailure('Math is broken', self.assertNotEqual, 54, | ||
| 304 | 1312 | dynamic_val) | ||
| 305 | 1313 | self.assertEqual(42, dynamic_val) | ||
| 306 | 1314 | |||
| 307 | 1315 | This means that a dynamic_val of 54 will cause the test to raise | ||
| 308 | 1316 | a KnownFailure. Once math is fixed and the expectFailure is removed, | ||
| 309 | 1317 | only a dynamic_val of 42 will allow the test to pass. Anything other | ||
| 310 | 1318 | than 54 or 42 will cause an AssertionError. | ||
| 311 | 1319 | """ | ||
| 312 | 1320 | try: | ||
| 313 | 1321 | assertion(*args, **kwargs) | ||
| 314 | 1322 | except AssertionError: | ||
| 315 | 1323 | raise KnownFailure(reason) | ||
| 316 | 1324 | else: | ||
| 317 | 1325 | self.fail('Unexpected success. Should have failed: %s' % reason) | ||
| 318 | 1326 | |||
| 319 | 1327 | def assertFileEqual(self, content, path): | 1286 | def assertFileEqual(self, content, path): |
| 320 | 1328 | """Fail if path does not contain 'content'.""" | 1287 | """Fail if path does not contain 'content'.""" |
| 321 | 1329 | self.failUnlessExists(path) | 1288 | self.failUnlessExists(path) |
| 322 | @@ -1479,18 +1438,12 @@ | |||
| 323 | 1479 | 1438 | ||
| 324 | 1480 | Close the file and delete it, unless setKeepLogfile was called. | 1439 | Close the file and delete it, unless setKeepLogfile was called. |
| 325 | 1481 | """ | 1440 | """ |
| 328 | 1482 | if self._log_file is None: | 1441 | if bzrlib.trace._trace_file: |
| 329 | 1483 | return | 1442 | # flush the log file, to get all content |
| 330 | 1443 | bzrlib.trace._trace_file.flush() | ||
| 331 | 1484 | bzrlib.trace.pop_log_file(self._log_memento) | 1444 | bzrlib.trace.pop_log_file(self._log_memento) |
| 341 | 1485 | self._log_file.close() | 1445 | # Cache the log result and delete the file on disk |
| 342 | 1486 | self._log_file = None | 1446 | self._get_log(False) |
| 334 | 1487 | if not self._keep_log_file: | ||
| 335 | 1488 | os.remove(self._log_file_name) | ||
| 336 | 1489 | self._log_file_name = None | ||
| 337 | 1490 | |||
| 338 | 1491 | def setKeepLogfile(self): | ||
| 339 | 1492 | """Make the logfile not be deleted when _finishLogFile is called.""" | ||
| 340 | 1493 | self._keep_log_file = True | ||
| 343 | 1494 | 1447 | ||
| 344 | 1495 | def thisFailsStrictLockCheck(self): | 1448 | def thisFailsStrictLockCheck(self): |
| 345 | 1496 | """It is known that this test would fail with -Dstrict_locks. | 1449 | """It is known that this test would fail with -Dstrict_locks. |
| 346 | @@ -1587,7 +1540,8 @@ | |||
| 347 | 1587 | else: | 1540 | else: |
| 348 | 1588 | addSkip(self, reason) | 1541 | addSkip(self, reason) |
| 349 | 1589 | 1542 | ||
| 351 | 1590 | def _do_known_failure(self, result): | 1543 | @staticmethod |
| 352 | 1544 | def _do_known_failure(self, result, e): | ||
| 353 | 1591 | err = sys.exc_info() | 1545 | err = sys.exc_info() |
| 354 | 1592 | addExpectedFailure = getattr(result, 'addExpectedFailure', None) | 1546 | addExpectedFailure = getattr(result, 'addExpectedFailure', None) |
| 355 | 1593 | if addExpectedFailure is not None: | 1547 | if addExpectedFailure is not None: |
| 356 | @@ -1595,6 +1549,7 @@ | |||
| 357 | 1595 | else: | 1549 | else: |
| 358 | 1596 | result.addSuccess(self) | 1550 | result.addSuccess(self) |
| 359 | 1597 | 1551 | ||
| 360 | 1552 | @staticmethod | ||
| 361 | 1598 | def _do_not_applicable(self, result, e): | 1553 | def _do_not_applicable(self, result, e): |
| 362 | 1599 | if not e.args: | 1554 | if not e.args: |
| 363 | 1600 | reason = 'No reason given' | 1555 | reason = 'No reason given' |
| 364 | @@ -1606,120 +1561,15 @@ | |||
| 365 | 1606 | else: | 1561 | else: |
| 366 | 1607 | self._do_skip(result, reason) | 1562 | self._do_skip(result, reason) |
| 367 | 1608 | 1563 | ||
| 369 | 1609 | def _do_unsupported_or_skip(self, result, reason): | 1564 | @staticmethod |
| 370 | 1565 | def _do_unsupported_or_skip(self, result, e): | ||
| 371 | 1566 | reason = e.args[0] | ||
| 372 | 1610 | addNotSupported = getattr(result, 'addNotSupported', None) | 1567 | addNotSupported = getattr(result, 'addNotSupported', None) |
| 373 | 1611 | if addNotSupported is not None: | 1568 | if addNotSupported is not None: |
| 374 | 1612 | result.addNotSupported(self, reason) | 1569 | result.addNotSupported(self, reason) |
| 375 | 1613 | else: | 1570 | else: |
| 376 | 1614 | self._do_skip(result, reason) | 1571 | self._do_skip(result, reason) |
| 377 | 1615 | 1572 | ||
| 378 | 1616 | def run(self, result=None): | ||
| 379 | 1617 | if result is None: result = self.defaultTestResult() | ||
| 380 | 1618 | result.startTest(self) | ||
| 381 | 1619 | try: | ||
| 382 | 1620 | self._run(result) | ||
| 383 | 1621 | return result | ||
| 384 | 1622 | finally: | ||
| 385 | 1623 | result.stopTest(self) | ||
| 386 | 1624 | |||
| 387 | 1625 | def _run(self, result): | ||
| 388 | 1626 | for feature in getattr(self, '_test_needs_features', []): | ||
| 389 | 1627 | if not feature.available(): | ||
| 390 | 1628 | return self._do_unsupported_or_skip(result, feature) | ||
| 391 | 1629 | try: | ||
| 392 | 1630 | absent_attr = object() | ||
| 393 | 1631 | # Python 2.5 | ||
| 394 | 1632 | method_name = getattr(self, '_testMethodName', absent_attr) | ||
| 395 | 1633 | if method_name is absent_attr: | ||
| 396 | 1634 | # Python 2.4 | ||
| 397 | 1635 | method_name = getattr(self, '_TestCase__testMethodName') | ||
| 398 | 1636 | testMethod = getattr(self, method_name) | ||
| 399 | 1637 | try: | ||
| 400 | 1638 | try: | ||
| 401 | 1639 | self.setUp() | ||
| 402 | 1640 | if not self._bzr_test_setUp_run: | ||
| 403 | 1641 | self.fail( | ||
| 404 | 1642 | "test setUp did not invoke " | ||
| 405 | 1643 | "bzrlib.tests.TestCase's setUp") | ||
| 406 | 1644 | except KeyboardInterrupt: | ||
| 407 | 1645 | self._runCleanups() | ||
| 408 | 1646 | raise | ||
| 409 | 1647 | except KnownFailure: | ||
| 410 | 1648 | self._do_known_failure(result) | ||
| 411 | 1649 | self.tearDown() | ||
| 412 | 1650 | return | ||
| 413 | 1651 | except TestNotApplicable, e: | ||
| 414 | 1652 | self._do_not_applicable(result, e) | ||
| 415 | 1653 | self.tearDown() | ||
| 416 | 1654 | return | ||
| 417 | 1655 | except TestSkipped, e: | ||
| 418 | 1656 | self._do_skip(result, e.args[0]) | ||
| 419 | 1657 | self.tearDown() | ||
| 420 | 1658 | return result | ||
| 421 | 1659 | except UnavailableFeature, e: | ||
| 422 | 1660 | self._do_unsupported_or_skip(result, e.args[0]) | ||
| 423 | 1661 | self.tearDown() | ||
| 424 | 1662 | return | ||
| 425 | 1663 | except: | ||
| 426 | 1664 | result.addError(self, sys.exc_info()) | ||
| 427 | 1665 | self._runCleanups() | ||
| 428 | 1666 | return result | ||
| 429 | 1667 | |||
| 430 | 1668 | ok = False | ||
| 431 | 1669 | try: | ||
| 432 | 1670 | testMethod() | ||
| 433 | 1671 | ok = True | ||
| 434 | 1672 | except KnownFailure: | ||
| 435 | 1673 | self._do_known_failure(result) | ||
| 436 | 1674 | except self.failureException: | ||
| 437 | 1675 | result.addFailure(self, sys.exc_info()) | ||
| 438 | 1676 | except TestNotApplicable, e: | ||
| 439 | 1677 | self._do_not_applicable(result, e) | ||
| 440 | 1678 | except TestSkipped, e: | ||
| 441 | 1679 | if not e.args: | ||
| 442 | 1680 | reason = "No reason given." | ||
| 443 | 1681 | else: | ||
| 444 | 1682 | reason = e.args[0] | ||
| 445 | 1683 | self._do_skip(result, reason) | ||
| 446 | 1684 | except UnavailableFeature, e: | ||
| 447 | 1685 | self._do_unsupported_or_skip(result, e.args[0]) | ||
| 448 | 1686 | except KeyboardInterrupt: | ||
| 449 | 1687 | self._runCleanups() | ||
| 450 | 1688 | raise | ||
| 451 | 1689 | except: | ||
| 452 | 1690 | result.addError(self, sys.exc_info()) | ||
| 453 | 1691 | |||
| 454 | 1692 | try: | ||
| 455 | 1693 | self.tearDown() | ||
| 456 | 1694 | if not self._bzr_test_tearDown_run: | ||
| 457 | 1695 | self.fail( | ||
| 458 | 1696 | "test tearDown did not invoke " | ||
| 459 | 1697 | "bzrlib.tests.TestCase's tearDown") | ||
| 460 | 1698 | except KeyboardInterrupt: | ||
| 461 | 1699 | self._runCleanups() | ||
| 462 | 1700 | raise | ||
| 463 | 1701 | except: | ||
| 464 | 1702 | result.addError(self, sys.exc_info()) | ||
| 465 | 1703 | self._runCleanups() | ||
| 466 | 1704 | ok = False | ||
| 467 | 1705 | if ok: result.addSuccess(self) | ||
| 468 | 1706 | return result | ||
| 469 | 1707 | except KeyboardInterrupt: | ||
| 470 | 1708 | self._runCleanups() | ||
| 471 | 1709 | raise | ||
| 472 | 1710 | finally: | ||
| 473 | 1711 | saved_attrs = {} | ||
| 474 | 1712 | for attr_name in self.attrs_to_keep: | ||
| 475 | 1713 | if attr_name in self.__dict__: | ||
| 476 | 1714 | saved_attrs[attr_name] = self.__dict__[attr_name] | ||
| 477 | 1715 | self.__dict__ = saved_attrs | ||
| 478 | 1716 | |||
| 479 | 1717 | def tearDown(self): | ||
| 480 | 1718 | self._runCleanups() | ||
| 481 | 1719 | self._log_contents = '' | ||
| 482 | 1720 | self._bzr_test_tearDown_run = True | ||
| 483 | 1721 | unittest.TestCase.tearDown(self) | ||
| 484 | 1722 | |||
| 485 | 1723 | def time(self, callable, *args, **kwargs): | 1573 | def time(self, callable, *args, **kwargs): |
| 486 | 1724 | """Run callable and accrue the time it takes to the benchmark time. | 1574 | """Run callable and accrue the time it takes to the benchmark time. |
| 487 | 1725 | 1575 | ||
| 488 | @@ -1728,6 +1578,8 @@ | |||
| 489 | 1728 | self._benchcalls. | 1578 | self._benchcalls. |
| 490 | 1729 | """ | 1579 | """ |
| 491 | 1730 | if self._benchtime is None: | 1580 | if self._benchtime is None: |
| 492 | 1581 | self.addDetail('benchtime', content.Content(content.ContentType( | ||
| 493 | 1582 | "text", "plain"), lambda:[str(self._benchtime)])) | ||
| 494 | 1731 | self._benchtime = 0 | 1583 | self._benchtime = 0 |
| 495 | 1732 | start = time.time() | 1584 | start = time.time() |
| 496 | 1733 | try: | 1585 | try: |
| 497 | @@ -1742,25 +1594,14 @@ | |||
| 498 | 1742 | finally: | 1594 | finally: |
| 499 | 1743 | self._benchtime += time.time() - start | 1595 | self._benchtime += time.time() - start |
| 500 | 1744 | 1596 | ||
| 501 | 1745 | def _runCleanups(self): | ||
| 502 | 1746 | """Run registered cleanup functions. | ||
| 503 | 1747 | |||
| 504 | 1748 | This should only be called from TestCase.tearDown. | ||
| 505 | 1749 | """ | ||
| 506 | 1750 | # TODO: Perhaps this should keep running cleanups even if | ||
| 507 | 1751 | # one of them fails? | ||
| 508 | 1752 | |||
| 509 | 1753 | # Actually pop the cleanups from the list so tearDown running | ||
| 510 | 1754 | # twice is safe (this happens for skipped tests). | ||
| 511 | 1755 | while self._cleanups: | ||
| 512 | 1756 | cleanup, args, kwargs = self._cleanups.pop() | ||
| 513 | 1757 | cleanup(*args, **kwargs) | ||
| 514 | 1758 | |||
| 515 | 1759 | def log(self, *args): | 1597 | def log(self, *args): |
| 516 | 1760 | mutter(*args) | 1598 | mutter(*args) |
| 517 | 1761 | 1599 | ||
| 518 | 1762 | def _get_log(self, keep_log_file=False): | 1600 | def _get_log(self, keep_log_file=False): |
| 520 | 1763 | """Get the log from bzrlib.trace calls from this test. | 1601 | """Internal helper to get the log from bzrlib.trace for this test. |
| 521 | 1602 | |||
| 522 | 1603 | Please use self.getDetails, or self.get_log to access this in test case | ||
| 523 | 1604 | code. | ||
| 524 | 1764 | 1605 | ||
| 525 | 1765 | :param keep_log_file: When True, if the log is still a file on disk | 1606 | :param keep_log_file: When True, if the log is still a file on disk |
| 526 | 1766 | leave it as a file on disk. When False, if the log is still a file | 1607 | leave it as a file on disk. When False, if the log is still a file |
| 527 | @@ -1768,21 +1609,33 @@ | |||
| 528 | 1768 | self._log_contents. | 1609 | self._log_contents. |
| 529 | 1769 | :return: A string containing the log. | 1610 | :return: A string containing the log. |
| 530 | 1770 | """ | 1611 | """ |
| 532 | 1771 | # flush the log file, to get all content | 1612 | if self._log_contents is not None: |
| 533 | 1613 | try: | ||
| 534 | 1614 | self._log_contents.decode('utf8') | ||
| 535 | 1615 | except UnicodeDecodeError: | ||
| 536 | 1616 | unicodestr = self._log_contents.decode('utf8', 'replace') | ||
| 537 | 1617 | self._log_contents = unicodestr.encode('utf8') | ||
| 538 | 1618 | return self._log_contents | ||
| 539 | 1772 | import bzrlib.trace | 1619 | import bzrlib.trace |
| 540 | 1773 | if bzrlib.trace._trace_file: | 1620 | if bzrlib.trace._trace_file: |
| 541 | 1621 | # flush the log file, to get all content | ||
| 542 | 1774 | bzrlib.trace._trace_file.flush() | 1622 | bzrlib.trace._trace_file.flush() |
| 543 | 1775 | if self._log_contents: | ||
| 544 | 1776 | # XXX: this can hardly contain the content flushed above --vila | ||
| 545 | 1777 | # 20080128 | ||
| 546 | 1778 | return self._log_contents | ||
| 547 | 1779 | if self._log_file_name is not None: | 1623 | if self._log_file_name is not None: |
| 548 | 1780 | logfile = open(self._log_file_name) | 1624 | logfile = open(self._log_file_name) |
| 549 | 1781 | try: | 1625 | try: |
| 550 | 1782 | log_contents = logfile.read() | 1626 | log_contents = logfile.read() |
| 551 | 1783 | finally: | 1627 | finally: |
| 552 | 1784 | logfile.close() | 1628 | logfile.close() |
| 553 | 1629 | try: | ||
| 554 | 1630 | log_contents.decode('utf8') | ||
| 555 | 1631 | except UnicodeDecodeError: | ||
| 556 | 1632 | unicodestr = log_contents.decode('utf8', 'replace') | ||
| 557 | 1633 | log_contents = unicodestr.encode('utf8') | ||
| 558 | 1785 | if not keep_log_file: | 1634 | if not keep_log_file: |
| 559 | 1635 | self._log_file.close() | ||
| 560 | 1636 | self._log_file = None | ||
| 561 | 1637 | # Permit multiple calls to get_log until we clean it up in | ||
| 562 | 1638 | # finishLogFile | ||
| 563 | 1786 | self._log_contents = log_contents | 1639 | self._log_contents = log_contents |
| 564 | 1787 | try: | 1640 | try: |
| 565 | 1788 | os.remove(self._log_file_name) | 1641 | os.remove(self._log_file_name) |
| 566 | @@ -1792,9 +1645,17 @@ | |||
| 567 | 1792 | ' %r\n' % self._log_file_name)) | 1645 | ' %r\n' % self._log_file_name)) |
| 568 | 1793 | else: | 1646 | else: |
| 569 | 1794 | raise | 1647 | raise |
| 570 | 1648 | self._log_file_name = None | ||
| 571 | 1795 | return log_contents | 1649 | return log_contents |
| 572 | 1796 | else: | 1650 | else: |
| 574 | 1797 | return "DELETED log file to reduce memory footprint" | 1651 | return "No log file content and no log file name." |
| 575 | 1652 | |||
| 576 | 1653 | def get_log(self): | ||
| 577 | 1654 | """Get a unicode string containing the log from bzrlib.trace. | ||
| 578 | 1655 | |||
| 579 | 1656 | Undecodable characters are replaced. | ||
| 580 | 1657 | """ | ||
| 581 | 1658 | return u"".join(self.getDetails()['log'].iter_text()) | ||
| 582 | 1798 | 1659 | ||
| 583 | 1799 | def requireFeature(self, feature): | 1660 | def requireFeature(self, feature): |
| 584 | 1800 | """This test requires a specific feature is available. | 1661 | """This test requires a specific feature is available. |
| 585 | @@ -3219,7 +3080,7 @@ | |||
| 586 | 3219 | if self.randomised: | 3080 | if self.randomised: |
| 587 | 3220 | return iter(self._tests) | 3081 | return iter(self._tests) |
| 588 | 3221 | self.randomised = True | 3082 | self.randomised = True |
| 590 | 3222 | self.stream.writeln("Randomizing test order using seed %s\n" % | 3083 | self.stream.write("Randomizing test order using seed %s\n\n" % |
| 591 | 3223 | (self.actual_seed())) | 3084 | (self.actual_seed())) |
| 592 | 3224 | # Initialise the random number generator. | 3085 | # Initialise the random number generator. |
| 593 | 3225 | random.seed(self.actual_seed()) | 3086 | random.seed(self.actual_seed()) |
| 594 | @@ -3310,7 +3171,7 @@ | |||
| 595 | 3310 | sys.stdin.close() | 3171 | sys.stdin.close() |
| 596 | 3311 | sys.stdin = None | 3172 | sys.stdin = None |
| 597 | 3312 | stream = os.fdopen(c2pwrite, 'wb', 1) | 3173 | stream = os.fdopen(c2pwrite, 'wb', 1) |
| 599 | 3313 | subunit_result = BzrAutoTimingTestResultDecorator( | 3174 | subunit_result = AutoTimingTestResultDecorator( |
| 600 | 3314 | TestProtocolClient(stream)) | 3175 | TestProtocolClient(stream)) |
| 601 | 3315 | process_suite.run(subunit_result) | 3176 | process_suite.run(subunit_result) |
| 602 | 3316 | finally: | 3177 | finally: |
| 603 | @@ -3408,56 +3269,10 @@ | |||
| 604 | 3408 | 3269 | ||
| 605 | 3409 | def addFailure(self, test, err): | 3270 | def addFailure(self, test, err): |
| 606 | 3410 | self.result.addFailure(test, err) | 3271 | self.result.addFailure(test, err) |
| 657 | 3411 | 3272 | ForwardingResult = testtools.ExtendedToOriginalDecorator | |
| 658 | 3412 | 3273 | ||
| 659 | 3413 | class BZRTransformingResult(ForwardingResult): | 3274 | |
| 660 | 3414 | 3275 | from subunit.test_results import AutoTimingTestResultDecorator | |
| 611 | 3415 | def addError(self, test, err): | ||
| 612 | 3416 | feature = self._error_looks_like('UnavailableFeature: ', err) | ||
| 613 | 3417 | if feature is not None: | ||
| 614 | 3418 | self.result.addNotSupported(test, feature) | ||
| 615 | 3419 | else: | ||
| 616 | 3420 | self.result.addError(test, err) | ||
| 617 | 3421 | |||
| 618 | 3422 | def addFailure(self, test, err): | ||
| 619 | 3423 | known = self._error_looks_like('KnownFailure: ', err) | ||
| 620 | 3424 | if known is not None: | ||
| 621 | 3425 | self.result.addExpectedFailure(test, | ||
| 622 | 3426 | [KnownFailure, KnownFailure(known), None]) | ||
| 623 | 3427 | else: | ||
| 624 | 3428 | self.result.addFailure(test, err) | ||
| 625 | 3429 | |||
| 626 | 3430 | def _error_looks_like(self, prefix, err): | ||
| 627 | 3431 | """Deserialize exception and returns the stringify value.""" | ||
| 628 | 3432 | import subunit | ||
| 629 | 3433 | value = None | ||
| 630 | 3434 | typ, exc, _ = err | ||
| 631 | 3435 | if isinstance(exc, subunit.RemoteException): | ||
| 632 | 3436 | # stringify the exception gives access to the remote traceback | ||
| 633 | 3437 | # We search the last line for 'prefix' | ||
| 634 | 3438 | lines = str(exc).split('\n') | ||
| 635 | 3439 | while lines and not lines[-1]: | ||
| 636 | 3440 | lines.pop(-1) | ||
| 637 | 3441 | if lines: | ||
| 638 | 3442 | if lines[-1].startswith(prefix): | ||
| 639 | 3443 | value = lines[-1][len(prefix):] | ||
| 640 | 3444 | return value | ||
| 641 | 3445 | |||
| 642 | 3446 | |||
| 643 | 3447 | try: | ||
| 644 | 3448 | from subunit.test_results import AutoTimingTestResultDecorator | ||
| 645 | 3449 | # Expected failure should be seen as a success not a failure Once subunit | ||
| 646 | 3450 | # provide native support for that, BZRTransformingResult and this class | ||
| 647 | 3451 | # will become useless. | ||
| 648 | 3452 | class BzrAutoTimingTestResultDecorator(AutoTimingTestResultDecorator): | ||
| 649 | 3453 | |||
| 650 | 3454 | def addExpectedFailure(self, test, err): | ||
| 651 | 3455 | self._before_event() | ||
| 652 | 3456 | return self._call_maybe("addExpectedFailure", self._degrade_skip, | ||
| 653 | 3457 | test, err) | ||
| 654 | 3458 | except ImportError: | ||
| 655 | 3459 | # Let's just define a no-op decorator | ||
| 656 | 3460 | BzrAutoTimingTestResultDecorator = lambda x:x | ||
| 661 | 3461 | 3276 | ||
| 662 | 3462 | 3277 | ||
| 663 | 3463 | class ProfileResult(ForwardingResult): | 3278 | class ProfileResult(ForwardingResult): |
| 664 | @@ -4478,7 +4293,7 @@ | |||
| 665 | 4478 | from subunit import TestProtocolClient | 4293 | from subunit import TestProtocolClient |
| 666 | 4479 | class SubUnitBzrRunner(TextTestRunner): | 4294 | class SubUnitBzrRunner(TextTestRunner): |
| 667 | 4480 | def run(self, test): | 4295 | def run(self, test): |
| 669 | 4481 | result = BzrAutoTimingTestResultDecorator( | 4296 | result = AutoTimingTestResultDecorator( |
| 670 | 4482 | TestProtocolClient(self.stream)) | 4297 | TestProtocolClient(self.stream)) |
| 671 | 4483 | test.run(result) | 4298 | test.run(result) |
| 672 | 4484 | return result | 4299 | return result |
| 673 | 4485 | 4300 | ||
| 674 | === modified file 'bzrlib/tests/blackbox/test_debug.py' | |||
| 675 | --- bzrlib/tests/blackbox/test_debug.py 2009-03-23 14:59:43 +0000 | |||
| 676 | +++ bzrlib/tests/blackbox/test_debug.py 2009-12-17 09:43:14 +0000 | |||
| 677 | @@ -38,5 +38,4 @@ | |||
| 678 | 38 | def test_dash_dlock(self): | 38 | def test_dash_dlock(self): |
| 679 | 39 | # With -Dlock, locking and unlocking is recorded into the log | 39 | # With -Dlock, locking and unlocking is recorded into the log |
| 680 | 40 | self.run_bzr("-Dlock init foo") | 40 | self.run_bzr("-Dlock init foo") |
| 683 | 41 | trace_messages = self._get_log(keep_log_file=True) | 41 | self.assertContainsRe(self.get_log(), "lock_write") |
| 682 | 42 | self.assertContainsRe(trace_messages, "lock_write") | ||
| 684 | 43 | 42 | ||
| 685 | === modified file 'bzrlib/tests/blackbox/test_exceptions.py' | |||
| 686 | --- bzrlib/tests/blackbox/test_exceptions.py 2009-08-20 06:25:02 +0000 | |||
| 687 | +++ bzrlib/tests/blackbox/test_exceptions.py 2009-12-17 09:43:14 +0000 | |||
| 688 | @@ -55,8 +55,7 @@ | |||
| 689 | 55 | os.mkdir('foo') | 55 | os.mkdir('foo') |
| 690 | 56 | bzrdir.BzrDirFormat5().initialize('foo') | 56 | bzrdir.BzrDirFormat5().initialize('foo') |
| 691 | 57 | out, err = self.run_bzr("status foo") | 57 | out, err = self.run_bzr("status foo") |
| 694 | 58 | self.assertContainsRe(self._get_log(keep_log_file=True), | 58 | self.assertContainsRe(self.get_log(), "bzr upgrade") |
| 693 | 59 | "bzr upgrade") | ||
| 695 | 60 | finally: | 59 | finally: |
| 696 | 61 | repository._deprecation_warning_done = True | 60 | repository._deprecation_warning_done = True |
| 697 | 62 | 61 | ||
| 698 | 63 | 62 | ||
| 699 | === modified file 'bzrlib/tests/per_pack_repository.py' | |||
| 700 | --- bzrlib/tests/per_pack_repository.py 2009-09-07 03:35:06 +0000 | |||
| 701 | +++ bzrlib/tests/per_pack_repository.py 2009-12-17 09:43:14 +0000 | |||
| 702 | @@ -687,9 +687,9 @@ | |||
| 703 | 687 | # abort_write_group will not raise an error | 687 | # abort_write_group will not raise an error |
| 704 | 688 | self.assertEqual(None, repo.abort_write_group(suppress_errors=True)) | 688 | self.assertEqual(None, repo.abort_write_group(suppress_errors=True)) |
| 705 | 689 | # But it does log an error | 689 | # But it does log an error |
| 709 | 690 | log_file = self._get_log(keep_log_file=True) | 690 | log = self.get_log() |
| 710 | 691 | self.assertContainsRe(log_file, 'abort_write_group failed') | 691 | self.assertContainsRe(log, 'abort_write_group failed') |
| 711 | 692 | self.assertContainsRe(log_file, r'INFO bzr: ERROR \(ignored\):') | 692 | self.assertContainsRe(log, r'INFO bzr: ERROR \(ignored\):') |
| 712 | 693 | if token is not None: | 693 | if token is not None: |
| 713 | 694 | repo.leave_lock_in_place() | 694 | repo.leave_lock_in_place() |
| 714 | 695 | 695 | ||
| 715 | 696 | 696 | ||
| 716 | === modified file 'bzrlib/tests/per_repository/test_check.py' | |||
| 717 | --- bzrlib/tests/per_repository/test_check.py 2009-08-30 23:51:10 +0000 | |||
| 718 | +++ bzrlib/tests/per_repository/test_check.py 2009-12-17 09:43:14 +0000 | |||
| 719 | @@ -46,8 +46,7 @@ | |||
| 720 | 46 | revid2 = tree.commit('2') | 46 | revid2 = tree.commit('2') |
| 721 | 47 | check_object = tree.branch.repository.check([revid1, revid2]) | 47 | check_object = tree.branch.repository.check([revid1, revid2]) |
| 722 | 48 | check_object.report_results(verbose=True) | 48 | check_object.report_results(verbose=True) |
| 725 | 49 | log = self._get_log(keep_log_file=True) | 49 | self.assertContainsRe(self.get_log(), "0 unreferenced text versions") |
| 724 | 50 | self.assertContainsRe(log, "0 unreferenced text versions") | ||
| 726 | 51 | 50 | ||
| 727 | 52 | 51 | ||
| 728 | 53 | class TestFindInconsistentRevisionParents(TestCaseWithBrokenRevisionIndex): | 52 | class TestFindInconsistentRevisionParents(TestCaseWithBrokenRevisionIndex): |
| 729 | @@ -90,13 +89,11 @@ | |||
| 730 | 90 | # contents of it! | 89 | # contents of it! |
| 731 | 91 | check_object = repo.check(['ignored']) | 90 | check_object = repo.check(['ignored']) |
| 732 | 92 | check_object.report_results(verbose=False) | 91 | check_object.report_results(verbose=False) |
| 736 | 93 | log = self._get_log(keep_log_file=True) | 92 | self.assertContainsRe(self.get_log(), |
| 737 | 94 | self.assertContainsRe( | 93 | '1 revisions have incorrect parents in the revision index') |
| 735 | 95 | log, '1 revisions have incorrect parents in the revision index') | ||
| 738 | 96 | check_object.report_results(verbose=True) | 94 | check_object.report_results(verbose=True) |
| 739 | 97 | log = self._get_log(keep_log_file=True) | ||
| 740 | 98 | self.assertContainsRe( | 95 | self.assertContainsRe( |
| 742 | 99 | log, | 96 | self.get_log(), |
| 743 | 100 | "revision-id has wrong parents in index: " | 97 | "revision-id has wrong parents in index: " |
| 744 | 101 | r"\('incorrect-parent',\) should be \(\)") | 98 | r"\('incorrect-parent',\) should be \(\)") |
| 745 | 102 | 99 | ||
| 746 | @@ -147,5 +144,5 @@ | |||
| 747 | 147 | rev_id = builder.commit('first post') | 144 | rev_id = builder.commit('first post') |
| 748 | 148 | result = repo.check(None, check_repo=True) | 145 | result = repo.check(None, check_repo=True) |
| 749 | 149 | result.report_results(True) | 146 | result.report_results(True) |
| 751 | 150 | log = self._get_log(keep_log_file=True) | 147 | log = self.get_log() |
| 752 | 151 | self.assertFalse('Missing' in log, "Something was missing in %r" % log) | 148 | self.assertFalse('Missing' in log, "Something was missing in %r" % log) |
| 753 | 152 | 149 | ||
| 754 | === modified file 'bzrlib/tests/per_repository/test_check_reconcile.py' | |||
| 755 | --- bzrlib/tests/per_repository/test_check_reconcile.py 2009-03-23 14:59:43 +0000 | |||
| 756 | +++ bzrlib/tests/per_repository/test_check_reconcile.py 2009-12-17 09:43:14 +0000 | |||
| 757 | @@ -198,10 +198,9 @@ | |||
| 758 | 198 | repo, scenario = self.prepare_test_repository() | 198 | repo, scenario = self.prepare_test_repository() |
| 759 | 199 | check_result = repo.check() | 199 | check_result = repo.check() |
| 760 | 200 | check_result.report_results(verbose=True) | 200 | check_result.report_results(verbose=True) |
| 761 | 201 | log = self.get_log() | ||
| 762 | 201 | for pattern in scenario.check_regexes(repo): | 202 | for pattern in scenario.check_regexes(repo): |
| 766 | 202 | self.assertContainsRe( | 203 | self.assertContainsRe(log, pattern) |
| 764 | 203 | self._get_log(keep_log_file=True), | ||
| 765 | 204 | pattern) | ||
| 767 | 205 | 204 | ||
| 768 | 206 | def test_find_text_key_references(self): | 205 | def test_find_text_key_references(self): |
| 769 | 207 | """Test that find_text_key_references finds erroneous references.""" | 206 | """Test that find_text_key_references finds erroneous references.""" |
| 770 | 208 | 207 | ||
| 771 | === modified file 'bzrlib/tests/per_repository_reference/test_check.py' | |||
| 772 | --- bzrlib/tests/per_repository_reference/test_check.py 2009-08-11 05:26:57 +0000 | |||
| 773 | +++ bzrlib/tests/per_repository_reference/test_check.py 2009-12-17 09:43:14 +0000 | |||
| 774 | @@ -39,5 +39,4 @@ | |||
| 775 | 39 | check_result = referring.branch.repository.check( | 39 | check_result = referring.branch.repository.check( |
| 776 | 40 | referring.branch.repository.all_revision_ids()) | 40 | referring.branch.repository.all_revision_ids()) |
| 777 | 41 | check_result.report_results(verbose=False) | 41 | check_result.report_results(verbose=False) |
| 780 | 42 | log = self._get_log(keep_log_file=True) | 42 | self.assertFalse("inconsistent parents" in self.get_log()) |
| 779 | 43 | self.assertFalse("inconsistent parents" in log) | ||
| 781 | 44 | 43 | ||
| 782 | === modified file 'bzrlib/tests/test_cleanup.py' | |||
| 783 | --- bzrlib/tests/test_cleanup.py 2009-10-26 06:23:14 +0000 | |||
| 784 | +++ bzrlib/tests/test_cleanup.py 2009-12-17 09:43:14 +0000 | |||
| 785 | @@ -39,8 +39,7 @@ | |||
| 786 | 39 | self.call_log.append('no_op_cleanup') | 39 | self.call_log.append('no_op_cleanup') |
| 787 | 40 | 40 | ||
| 788 | 41 | def assertLogContains(self, regex): | 41 | def assertLogContains(self, regex): |
| 791 | 42 | log = self._get_log(keep_log_file=True) | 42 | self.assertContainsRe(self.get_log(), regex, re.DOTALL) |
| 790 | 43 | self.assertContainsRe(log, regex, re.DOTALL) | ||
| 792 | 44 | 43 | ||
| 793 | 45 | def failing_cleanup(self): | 44 | def failing_cleanup(self): |
| 794 | 46 | self.call_log.append('failing_cleanup') | 45 | self.call_log.append('failing_cleanup') |
| 795 | @@ -184,8 +183,7 @@ | |||
| 796 | 184 | self.assertRaises(ErrorA, _do_with_cleanups, cleanups, | 183 | self.assertRaises(ErrorA, _do_with_cleanups, cleanups, |
| 797 | 185 | self.trivial_func) | 184 | self.trivial_func) |
| 798 | 186 | self.assertLogContains('Cleanup failed:.*ErrorB') | 185 | self.assertLogContains('Cleanup failed:.*ErrorB') |
| 801 | 187 | log = self._get_log(keep_log_file=True) | 186 | self.assertFalse('ErrorA' in self.get_log()) |
| 800 | 188 | self.assertFalse('ErrorA' in log) | ||
| 802 | 189 | 187 | ||
| 803 | 190 | def make_two_failing_cleanup_funcs(self): | 188 | def make_two_failing_cleanup_funcs(self): |
| 804 | 191 | def raise_a(): | 189 | def raise_a(): |
| 805 | 192 | 190 | ||
| 806 | === modified file 'bzrlib/tests/test_config.py' | |||
| 807 | --- bzrlib/tests/test_config.py 2009-10-31 01:43:48 +0000 | |||
| 808 | +++ bzrlib/tests/test_config.py 2009-12-17 09:43:14 +0000 | |||
| 809 | @@ -1600,7 +1600,7 @@ | |||
| 810 | 1600 | self.assertEquals(entered_password, | 1600 | self.assertEquals(entered_password, |
| 811 | 1601 | conf.get_password('ssh', 'bar.org', user='jim')) | 1601 | conf.get_password('ssh', 'bar.org', user='jim')) |
| 812 | 1602 | self.assertContainsRe( | 1602 | self.assertContainsRe( |
| 814 | 1603 | self._get_log(keep_log_file=True), | 1603 | self.get_log(), |
| 815 | 1604 | 'password ignored in section \[ssh with password\]') | 1604 | 'password ignored in section \[ssh with password\]') |
| 816 | 1605 | 1605 | ||
| 817 | 1606 | def test_ssh_without_password_doesnt_emit_warning(self): | 1606 | def test_ssh_without_password_doesnt_emit_warning(self): |
| 818 | @@ -1625,7 +1625,7 @@ | |||
| 819 | 1625 | # No warning shoud be emitted since there is no password. We are only | 1625 | # No warning shoud be emitted since there is no password. We are only |
| 820 | 1626 | # providing "user". | 1626 | # providing "user". |
| 821 | 1627 | self.assertNotContainsRe( | 1627 | self.assertNotContainsRe( |
| 823 | 1628 | self._get_log(keep_log_file=True), | 1628 | self.get_log(), |
| 824 | 1629 | 'password ignored in section \[ssh with password\]') | 1629 | 'password ignored in section \[ssh with password\]') |
| 825 | 1630 | 1630 | ||
| 826 | 1631 | def test_uses_fallback_stores(self): | 1631 | def test_uses_fallback_stores(self): |
| 827 | 1632 | 1632 | ||
| 828 | === modified file 'bzrlib/tests/test_http_response.py' | |||
| 829 | --- bzrlib/tests/test_http_response.py 2009-03-23 14:59:43 +0000 | |||
| 830 | +++ bzrlib/tests/test_http_response.py 2009-12-17 09:43:14 +0000 | |||
| 831 | @@ -96,8 +96,7 @@ | |||
| 832 | 96 | # Override the thresold to force the warning emission | 96 | # Override the thresold to force the warning emission |
| 833 | 97 | conn._range_warning_thresold = 6 # There are 7 bytes pending | 97 | conn._range_warning_thresold = 6 # There are 7 bytes pending |
| 834 | 98 | conn.cleanup_pipe() | 98 | conn.cleanup_pipe() |
| 837 | 99 | self.assertContainsRe(self._get_log(keep_log_file=True), | 99 | self.assertContainsRe(self.get_log(), 'Got a 200 response when asking') |
| 836 | 100 | 'Got a 200 response when asking') | ||
| 838 | 101 | 100 | ||
| 839 | 102 | 101 | ||
| 840 | 103 | class TestRangeFileMixin(object): | 102 | class TestRangeFileMixin(object): |
| 841 | 104 | 103 | ||
| 842 | === modified file 'bzrlib/tests/test_merge.py' | |||
| 843 | --- bzrlib/tests/test_merge.py 2009-12-10 17:16:19 +0000 | |||
| 844 | +++ bzrlib/tests/test_merge.py 2009-12-17 09:43:14 +0000 | |||
| 845 | @@ -152,13 +152,12 @@ | |||
| 846 | 152 | log = StringIO() | 152 | log = StringIO() |
| 847 | 153 | merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), | 153 | merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), |
| 848 | 154 | this_tree=tree_b, ignore_zero=True) | 154 | this_tree=tree_b, ignore_zero=True) |
| 851 | 155 | log = self._get_log(keep_log_file=True) | 155 | self.failUnless('All changes applied successfully.\n' not in |
| 852 | 156 | self.failUnless('All changes applied successfully.\n' not in log) | 156 | self.get_log()) |
| 853 | 157 | tree_b.revert() | 157 | tree_b.revert() |
| 854 | 158 | merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), | 158 | merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), |
| 855 | 159 | this_tree=tree_b, ignore_zero=False) | 159 | this_tree=tree_b, ignore_zero=False) |
| 858 | 160 | log = self._get_log(keep_log_file=True) | 160 | self.failUnless('All changes applied successfully.\n' in self.get_log()) |
| 857 | 161 | self.failUnless('All changes applied successfully.\n' in log) | ||
| 859 | 162 | 161 | ||
| 860 | 163 | def test_merge_inner_conflicts(self): | 162 | def test_merge_inner_conflicts(self): |
| 861 | 164 | tree_a = self.make_branch_and_tree('a') | 163 | tree_a = self.make_branch_and_tree('a') |
| 862 | 165 | 164 | ||
| 863 | === modified file 'bzrlib/tests/test_remote.py' | |||
| 864 | --- bzrlib/tests/test_remote.py 2009-12-03 20:34:03 +0000 | |||
| 865 | +++ bzrlib/tests/test_remote.py 2009-12-17 09:43:14 +0000 | |||
| 866 | @@ -2893,7 +2893,7 @@ | |||
| 867 | 2893 | # In addition to re-raising ErrorFromSmartServer, some debug info has | 2893 | # In addition to re-raising ErrorFromSmartServer, some debug info has |
| 868 | 2894 | # been muttered to the log file for developer to look at. | 2894 | # been muttered to the log file for developer to look at. |
| 869 | 2895 | self.assertContainsRe( | 2895 | self.assertContainsRe( |
| 871 | 2896 | self._get_log(keep_log_file=True), | 2896 | self.get_log(), |
| 872 | 2897 | "Missing key 'branch' in context") | 2897 | "Missing key 'branch' in context") |
| 873 | 2898 | 2898 | ||
| 874 | 2899 | def test_path_missing(self): | 2899 | def test_path_missing(self): |
| 875 | @@ -2907,8 +2907,7 @@ | |||
| 876 | 2907 | self.assertEqual(server_error, translated_error) | 2907 | self.assertEqual(server_error, translated_error) |
| 877 | 2908 | # In addition to re-raising ErrorFromSmartServer, some debug info has | 2908 | # In addition to re-raising ErrorFromSmartServer, some debug info has |
| 878 | 2909 | # been muttered to the log file for developer to look at. | 2909 | # been muttered to the log file for developer to look at. |
| 881 | 2910 | self.assertContainsRe( | 2910 | self.assertContainsRe(self.get_log(), "Missing key 'path' in context") |
| 880 | 2911 | self._get_log(keep_log_file=True), "Missing key 'path' in context") | ||
| 882 | 2912 | 2911 | ||
| 883 | 2913 | 2912 | ||
| 884 | 2914 | class TestStacking(tests.TestCaseWithTransport): | 2913 | class TestStacking(tests.TestCaseWithTransport): |
| 885 | 2915 | 2914 | ||
| 886 | === modified file 'bzrlib/tests/test_selftest.py' | |||
| 887 | --- bzrlib/tests/test_selftest.py 2009-12-08 21:46:07 +0000 | |||
| 888 | +++ bzrlib/tests/test_selftest.py 2009-12-17 09:43:14 +0000 | |||
| 889 | @@ -17,6 +17,7 @@ | |||
| 890 | 17 | """Tests for the test framework.""" | 17 | """Tests for the test framework.""" |
| 891 | 18 | 18 | ||
| 892 | 19 | from cStringIO import StringIO | 19 | from cStringIO import StringIO |
| 893 | 20 | from doctest import ELLIPSIS | ||
| 894 | 20 | import os | 21 | import os |
| 895 | 21 | import signal | 22 | import signal |
| 896 | 22 | import sys | 23 | import sys |
| 897 | @@ -24,6 +25,14 @@ | |||
| 898 | 24 | import unittest | 25 | import unittest |
| 899 | 25 | import warnings | 26 | import warnings |
| 900 | 26 | 27 | ||
| 901 | 28 | from testtools import MultiTestResult | ||
| 902 | 29 | from testtools.content_type import ContentType | ||
| 903 | 30 | from testtools.matchers import ( | ||
| 904 | 31 | DocTestMatches, | ||
| 905 | 32 | Equals, | ||
| 906 | 33 | ) | ||
| 907 | 34 | import testtools.tests.helpers | ||
| 908 | 35 | |||
| 909 | 27 | import bzrlib | 36 | import bzrlib |
| 910 | 28 | from bzrlib import ( | 37 | from bzrlib import ( |
| 911 | 29 | branchbuilder, | 38 | branchbuilder, |
| 912 | @@ -78,14 +87,19 @@ | |||
| 913 | 78 | TestUtil._load_module_by_name, | 87 | TestUtil._load_module_by_name, |
| 914 | 79 | 'bzrlib.no-name-yet') | 88 | 'bzrlib.no-name-yet') |
| 915 | 80 | 89 | ||
| 916 | 90 | |||
| 917 | 81 | class MetaTestLog(tests.TestCase): | 91 | class MetaTestLog(tests.TestCase): |
| 918 | 82 | 92 | ||
| 919 | 83 | def test_logging(self): | 93 | def test_logging(self): |
| 920 | 84 | """Test logs are captured when a test fails.""" | 94 | """Test logs are captured when a test fails.""" |
| 921 | 85 | self.log('a test message') | 95 | self.log('a test message') |
| 925 | 86 | self._log_file.flush() | 96 | details = self.getDetails() |
| 926 | 87 | self.assertContainsRe(self._get_log(keep_log_file=True), | 97 | log = details['log'] |
| 927 | 88 | 'a test message\n') | 98 | self.assertThat(log.content_type, Equals(ContentType( |
| 928 | 99 | "text", "plain", {"charset": "utf8"}))) | ||
| 929 | 100 | self.assertThat(u"".join(log.iter_text()), Equals(self.get_log())) | ||
| 930 | 101 | self.assertThat(self.get_log(), | ||
| 931 | 102 | DocTestMatches(u"...a test message\n", ELLIPSIS)) | ||
| 932 | 89 | 103 | ||
| 933 | 90 | 104 | ||
| 934 | 91 | class TestUnicodeFilename(tests.TestCase): | 105 | class TestUnicodeFilename(tests.TestCase): |
| 935 | @@ -687,7 +701,7 @@ | |||
| 936 | 687 | 701 | ||
| 937 | 688 | def test_profiles_tests(self): | 702 | def test_profiles_tests(self): |
| 938 | 689 | self.requireFeature(test_lsprof.LSProfFeature) | 703 | self.requireFeature(test_lsprof.LSProfFeature) |
| 940 | 690 | terminal = unittest.TestResult() | 704 | terminal = testtools.tests.helpers.ExtendedTestResult() |
| 941 | 691 | result = tests.ProfileResult(terminal) | 705 | result = tests.ProfileResult(terminal) |
| 942 | 692 | class Sample(tests.TestCase): | 706 | class Sample(tests.TestCase): |
| 943 | 693 | def a(self): | 707 | def a(self): |
| 944 | @@ -695,11 +709,11 @@ | |||
| 945 | 695 | def sample_function(self): | 709 | def sample_function(self): |
| 946 | 696 | pass | 710 | pass |
| 947 | 697 | test = Sample("a") | 711 | test = Sample("a") |
| 948 | 698 | test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',) | ||
| 949 | 699 | test.run(result) | 712 | test.run(result) |
| 951 | 700 | self.assertLength(1, test._benchcalls) | 713 | case = terminal._events[0][1] |
| 952 | 714 | self.assertLength(1, case._benchcalls) | ||
| 953 | 701 | # We must be able to unpack it as the test reporting code wants | 715 | # We must be able to unpack it as the test reporting code wants |
| 955 | 702 | (_, _, _), stats = test._benchcalls[0] | 716 | (_, _, _), stats = case._benchcalls[0] |
| 956 | 703 | self.assertTrue(callable(stats.pprint)) | 717 | self.assertTrue(callable(stats.pprint)) |
| 957 | 704 | 718 | ||
| 958 | 705 | 719 | ||
| 959 | @@ -710,8 +724,10 @@ | |||
| 960 | 710 | descriptions=0, | 724 | descriptions=0, |
| 961 | 711 | verbosity=1, | 725 | verbosity=1, |
| 962 | 712 | ) | 726 | ) |
| 965 | 713 | test_case.run(result) | 727 | capture = testtools.tests.helpers.ExtendedTestResult() |
| 966 | 714 | timed_string = result._testTimeString(test_case) | 728 | test_case.run(MultiTestResult(result, capture)) |
| 967 | 729 | run_case = capture._events[0][1] | ||
| 968 | 730 | timed_string = result._testTimeString(run_case) | ||
| 969 | 715 | self.assertContainsRe(timed_string, expected_re) | 731 | self.assertContainsRe(timed_string, expected_re) |
| 970 | 716 | 732 | ||
| 971 | 717 | def test_test_reporting(self): | 733 | def test_test_reporting(self): |
| 972 | @@ -832,8 +848,8 @@ | |||
| 973 | 832 | def stopTestRun(self): pass | 848 | def stopTestRun(self): pass |
| 974 | 833 | def startTests(self): pass | 849 | def startTests(self): pass |
| 975 | 834 | def report_test_start(self, test): pass | 850 | def report_test_start(self, test): pass |
| 978 | 835 | def report_known_failure(self, test, err): | 851 | def report_known_failure(self, test, err=None, details=None): |
| 979 | 836 | self._call = test, err | 852 | self._call = test, 'known failure' |
| 980 | 837 | result = InstrumentedTestResult(None, None, None, None) | 853 | result = InstrumentedTestResult(None, None, None, None) |
| 981 | 838 | class Test(tests.TestCase): | 854 | class Test(tests.TestCase): |
| 982 | 839 | def test_function(self): | 855 | def test_function(self): |
| 983 | @@ -842,9 +858,8 @@ | |||
| 984 | 842 | test.run(result) | 858 | test.run(result) |
| 985 | 843 | # it should invoke 'report_known_failure'. | 859 | # it should invoke 'report_known_failure'. |
| 986 | 844 | self.assertEqual(2, len(result._call)) | 860 | self.assertEqual(2, len(result._call)) |
| 990 | 845 | self.assertEqual(test, result._call[0]) | 861 | self.assertEqual(test.id(), result._call[0].id()) |
| 991 | 846 | self.assertEqual(tests.KnownFailure, result._call[1][0]) | 862 | self.assertEqual('known failure', result._call[1]) |
| 989 | 847 | self.assertIsInstance(result._call[1][1], tests.KnownFailure) | ||
| 992 | 848 | # we dont introspec the traceback, if the rest is ok, it would be | 863 | # we dont introspec the traceback, if the rest is ok, it would be |
| 993 | 849 | # exceptional for it not to be. | 864 | # exceptional for it not to be. |
| 994 | 850 | # it should update the known_failure_count on the object. | 865 | # it should update the known_failure_count on the object. |
| 995 | @@ -944,7 +959,7 @@ | |||
| 996 | 944 | test.run(result) | 959 | test.run(result) |
| 997 | 945 | # it should invoke 'addNotSupported'. | 960 | # it should invoke 'addNotSupported'. |
| 998 | 946 | self.assertEqual(2, len(result._call)) | 961 | self.assertEqual(2, len(result._call)) |
| 1000 | 947 | self.assertEqual(test, result._call[0]) | 962 | self.assertEqual(test.id(), result._call[0].id()) |
| 1001 | 948 | self.assertEqual(feature, result._call[1]) | 963 | self.assertEqual(feature, result._call[1]) |
| 1002 | 949 | # and not count as an error | 964 | # and not count as an error |
| 1003 | 950 | self.assertEqual(0, result.error_count) | 965 | self.assertEqual(0, result.error_count) |
| 1004 | @@ -1028,25 +1043,25 @@ | |||
| 1005 | 1028 | # the final output when real failures occur. | 1043 | # the final output when real failures occur. |
| 1006 | 1029 | class Test(tests.TestCase): | 1044 | class Test(tests.TestCase): |
| 1007 | 1030 | def known_failure_test(self): | 1045 | def known_failure_test(self): |
| 1009 | 1031 | raise tests.KnownFailure('failed') | 1046 | self.expectFailure('failed', self.assertTrue, False) |
| 1010 | 1032 | test = unittest.TestSuite() | 1047 | test = unittest.TestSuite() |
| 1011 | 1033 | test.addTest(Test("known_failure_test")) | 1048 | test.addTest(Test("known_failure_test")) |
| 1012 | 1034 | def failing_test(): | 1049 | def failing_test(): |
| 1014 | 1035 | raise AssertionError('foo') | 1050 | self.fail('foo') |
| 1015 | 1036 | test.addTest(unittest.FunctionTestCase(failing_test)) | 1051 | test.addTest(unittest.FunctionTestCase(failing_test)) |
| 1016 | 1037 | stream = StringIO() | 1052 | stream = StringIO() |
| 1017 | 1038 | runner = tests.TextTestRunner(stream=stream) | 1053 | runner = tests.TextTestRunner(stream=stream) |
| 1018 | 1039 | result = self.run_test_runner(runner, test) | 1054 | result = self.run_test_runner(runner, test) |
| 1019 | 1040 | lines = stream.getvalue().splitlines() | 1055 | lines = stream.getvalue().splitlines() |
| 1020 | 1041 | self.assertContainsRe(stream.getvalue(), | 1056 | self.assertContainsRe(stream.getvalue(), |
| 1022 | 1042 | '(?sm)^testing.*$' | 1057 | '(?sm)^bzr selftest.*$' |
| 1023 | 1043 | '.*' | 1058 | '.*' |
| 1024 | 1044 | '^======================================================================\n' | 1059 | '^======================================================================\n' |
| 1025 | 1045 | '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n' | 1060 | '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n' |
| 1026 | 1046 | '^----------------------------------------------------------------------\n' | 1061 | '^----------------------------------------------------------------------\n' |
| 1027 | 1047 | 'Traceback \\(most recent call last\\):\n' | 1062 | 'Traceback \\(most recent call last\\):\n' |
| 1028 | 1048 | ' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc | 1063 | ' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc |
| 1030 | 1049 | ' raise AssertionError\\(\'foo\'\\)\n' | 1064 | ' self.fail\\(\'foo\'\\)\n' |
| 1031 | 1050 | '.*' | 1065 | '.*' |
| 1032 | 1051 | '^----------------------------------------------------------------------\n' | 1066 | '^----------------------------------------------------------------------\n' |
| 1033 | 1052 | '.*' | 1067 | '.*' |
| 1034 | @@ -1058,7 +1073,7 @@ | |||
| 1035 | 1058 | # the final output. | 1073 | # the final output. |
| 1036 | 1059 | class Test(tests.TestCase): | 1074 | class Test(tests.TestCase): |
| 1037 | 1060 | def known_failure_test(self): | 1075 | def known_failure_test(self): |
| 1039 | 1061 | raise tests.KnownFailure('failed') | 1076 | self.expectFailure('failed', self.assertTrue, False) |
| 1040 | 1062 | test = Test("known_failure_test") | 1077 | test = Test("known_failure_test") |
| 1041 | 1063 | stream = StringIO() | 1078 | stream = StringIO() |
| 1042 | 1064 | runner = tests.TextTestRunner(stream=stream) | 1079 | runner = tests.TextTestRunner(stream=stream) |
| 1043 | @@ -1209,119 +1224,6 @@ | |||
| 1044 | 1209 | self.assertContainsRe(output_string, "--date [0-9.]+") | 1224 | self.assertContainsRe(output_string, "--date [0-9.]+") |
| 1045 | 1210 | self.assertLength(1, self._get_source_tree_calls) | 1225 | self.assertLength(1, self._get_source_tree_calls) |
| 1046 | 1211 | 1226 | ||
| 1047 | 1212 | def assertLogDeleted(self, test): | ||
| 1048 | 1213 | log = test._get_log() | ||
| 1049 | 1214 | self.assertEqual("DELETED log file to reduce memory footprint", log) | ||
| 1050 | 1215 | self.assertEqual('', test._log_contents) | ||
| 1051 | 1216 | self.assertIs(None, test._log_file_name) | ||
| 1052 | 1217 | |||
| 1053 | 1218 | def test_success_log_deleted(self): | ||
| 1054 | 1219 | """Successful tests have their log deleted""" | ||
| 1055 | 1220 | |||
| 1056 | 1221 | class LogTester(tests.TestCase): | ||
| 1057 | 1222 | |||
| 1058 | 1223 | def test_success(self): | ||
| 1059 | 1224 | self.log('this will be removed\n') | ||
| 1060 | 1225 | |||
| 1061 | 1226 | sio = StringIO() | ||
| 1062 | 1227 | runner = tests.TextTestRunner(stream=sio) | ||
| 1063 | 1228 | test = LogTester('test_success') | ||
| 1064 | 1229 | result = self.run_test_runner(runner, test) | ||
| 1065 | 1230 | |||
| 1066 | 1231 | self.assertLogDeleted(test) | ||
| 1067 | 1232 | |||
| 1068 | 1233 | def test_skipped_log_deleted(self): | ||
| 1069 | 1234 | """Skipped tests have their log deleted""" | ||
| 1070 | 1235 | |||
| 1071 | 1236 | class LogTester(tests.TestCase): | ||
| 1072 | 1237 | |||
| 1073 | 1238 | def test_skipped(self): | ||
| 1074 | 1239 | self.log('this will be removed\n') | ||
| 1075 | 1240 | raise tests.TestSkipped() | ||
| 1076 | 1241 | |||
| 1077 | 1242 | sio = StringIO() | ||
| 1078 | 1243 | runner = tests.TextTestRunner(stream=sio) | ||
| 1079 | 1244 | test = LogTester('test_skipped') | ||
| 1080 | 1245 | result = self.run_test_runner(runner, test) | ||
| 1081 | 1246 | |||
| 1082 | 1247 | self.assertLogDeleted(test) | ||
| 1083 | 1248 | |||
| 1084 | 1249 | def test_not_aplicable_log_deleted(self): | ||
| 1085 | 1250 | """Not applicable tests have their log deleted""" | ||
| 1086 | 1251 | |||
| 1087 | 1252 | class LogTester(tests.TestCase): | ||
| 1088 | 1253 | |||
| 1089 | 1254 | def test_not_applicable(self): | ||
| 1090 | 1255 | self.log('this will be removed\n') | ||
| 1091 | 1256 | raise tests.TestNotApplicable() | ||
| 1092 | 1257 | |||
| 1093 | 1258 | sio = StringIO() | ||
| 1094 | 1259 | runner = tests.TextTestRunner(stream=sio) | ||
| 1095 | 1260 | test = LogTester('test_not_applicable') | ||
| 1096 | 1261 | result = self.run_test_runner(runner, test) | ||
| 1097 | 1262 | |||
| 1098 | 1263 | self.assertLogDeleted(test) | ||
| 1099 | 1264 | |||
| 1100 | 1265 | def test_known_failure_log_deleted(self): | ||
| 1101 | 1266 | """Know failure tests have their log deleted""" | ||
| 1102 | 1267 | |||
| 1103 | 1268 | class LogTester(tests.TestCase): | ||
| 1104 | 1269 | |||
| 1105 | 1270 | def test_known_failure(self): | ||
| 1106 | 1271 | self.log('this will be removed\n') | ||
| 1107 | 1272 | raise tests.KnownFailure() | ||
| 1108 | 1273 | |||
| 1109 | 1274 | sio = StringIO() | ||
| 1110 | 1275 | runner = tests.TextTestRunner(stream=sio) | ||
| 1111 | 1276 | test = LogTester('test_known_failure') | ||
| 1112 | 1277 | result = self.run_test_runner(runner, test) | ||
| 1113 | 1278 | |||
| 1114 | 1279 | self.assertLogDeleted(test) | ||
| 1115 | 1280 | |||
| 1116 | 1281 | def test_fail_log_kept(self): | ||
| 1117 | 1282 | """Failed tests have their log kept""" | ||
| 1118 | 1283 | |||
| 1119 | 1284 | class LogTester(tests.TestCase): | ||
| 1120 | 1285 | |||
| 1121 | 1286 | def test_fail(self): | ||
| 1122 | 1287 | self.log('this will be kept\n') | ||
| 1123 | 1288 | self.fail('this test fails') | ||
| 1124 | 1289 | |||
| 1125 | 1290 | sio = StringIO() | ||
| 1126 | 1291 | runner = tests.TextTestRunner(stream=sio) | ||
| 1127 | 1292 | test = LogTester('test_fail') | ||
| 1128 | 1293 | result = self.run_test_runner(runner, test) | ||
| 1129 | 1294 | |||
| 1130 | 1295 | text = sio.getvalue() | ||
| 1131 | 1296 | self.assertContainsRe(text, 'this will be kept') | ||
| 1132 | 1297 | self.assertContainsRe(text, 'this test fails') | ||
| 1133 | 1298 | |||
| 1134 | 1299 | log = test._get_log() | ||
| 1135 | 1300 | self.assertContainsRe(log, 'this will be kept') | ||
| 1136 | 1301 | self.assertEqual(log, test._log_contents) | ||
| 1137 | 1302 | |||
| 1138 | 1303 | def test_error_log_kept(self): | ||
| 1139 | 1304 | """Tests with errors have their log kept""" | ||
| 1140 | 1305 | |||
| 1141 | 1306 | class LogTester(tests.TestCase): | ||
| 1142 | 1307 | |||
| 1143 | 1308 | def test_error(self): | ||
| 1144 | 1309 | self.log('this will be kept\n') | ||
| 1145 | 1310 | raise ValueError('random exception raised') | ||
| 1146 | 1311 | |||
| 1147 | 1312 | sio = StringIO() | ||
| 1148 | 1313 | runner = tests.TextTestRunner(stream=sio) | ||
| 1149 | 1314 | test = LogTester('test_error') | ||
| 1150 | 1315 | result = self.run_test_runner(runner, test) | ||
| 1151 | 1316 | |||
| 1152 | 1317 | text = sio.getvalue() | ||
| 1153 | 1318 | self.assertContainsRe(text, 'this will be kept') | ||
| 1154 | 1319 | self.assertContainsRe(text, 'random exception raised') | ||
| 1155 | 1320 | |||
| 1156 | 1321 | log = test._get_log() | ||
| 1157 | 1322 | self.assertContainsRe(log, 'this will be kept') | ||
| 1158 | 1323 | self.assertEqual(log, test._log_contents) | ||
| 1159 | 1324 | |||
| 1160 | 1325 | def test_startTestRun(self): | 1227 | def test_startTestRun(self): |
| 1161 | 1326 | """run should call result.startTestRun()""" | 1228 | """run should call result.startTestRun()""" |
| 1162 | 1327 | calls = [] | 1229 | calls = [] |
| 1163 | @@ -1491,6 +1393,7 @@ | |||
| 1164 | 1491 | self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags) | 1393 | self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags) |
| 1165 | 1492 | 1394 | ||
| 1166 | 1493 | def make_test_result(self): | 1395 | def make_test_result(self): |
| 1167 | 1396 | """Get a test result that writes to the test log file.""" | ||
| 1168 | 1494 | return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1) | 1397 | return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1) |
| 1169 | 1495 | 1398 | ||
| 1170 | 1496 | def inner_test(self): | 1399 | def inner_test(self): |
| 1171 | @@ -1504,6 +1407,7 @@ | |||
| 1172 | 1504 | result = self.make_test_result() | 1407 | result = self.make_test_result() |
| 1173 | 1505 | self.inner_test.run(result) | 1408 | self.inner_test.run(result) |
| 1174 | 1506 | note("outer finish") | 1409 | note("outer finish") |
| 1175 | 1410 | self.addCleanup(osutils.delete_any, self._log_file_name) | ||
| 1176 | 1507 | 1411 | ||
| 1177 | 1508 | def test_trace_nesting(self): | 1412 | def test_trace_nesting(self): |
| 1178 | 1509 | # this tests that each test case nests its trace facility correctly. | 1413 | # this tests that each test case nests its trace facility correctly. |
| 1179 | @@ -1521,7 +1425,6 @@ | |||
| 1180 | 1521 | outer_test = TestTestCase("outer_child") | 1425 | outer_test = TestTestCase("outer_child") |
| 1181 | 1522 | result = self.make_test_result() | 1426 | result = self.make_test_result() |
| 1182 | 1523 | outer_test.run(result) | 1427 | outer_test.run(result) |
| 1183 | 1524 | self.addCleanup(osutils.delete_any, outer_test._log_file_name) | ||
| 1184 | 1525 | self.assertEqual(original_trace, bzrlib.trace._trace_file) | 1428 | self.assertEqual(original_trace, bzrlib.trace._trace_file) |
| 1185 | 1526 | 1429 | ||
| 1186 | 1527 | def method_that_times_a_bit_twice(self): | 1430 | def method_that_times_a_bit_twice(self): |
| 1187 | @@ -1642,6 +1545,8 @@ | |||
| 1188 | 1642 | """Test disabled tests behaviour with support aware results.""" | 1545 | """Test disabled tests behaviour with support aware results.""" |
| 1189 | 1643 | test = SampleTestCase('_test_pass') | 1546 | test = SampleTestCase('_test_pass') |
| 1190 | 1644 | class DisabledFeature(object): | 1547 | class DisabledFeature(object): |
| 1191 | 1548 | def __eq__(self, other): | ||
| 1192 | 1549 | return isinstance(other, DisabledFeature) | ||
| 1193 | 1645 | def available(self): | 1550 | def available(self): |
| 1194 | 1646 | return False | 1551 | return False |
| 1195 | 1647 | the_feature = DisabledFeature() | 1552 | the_feature = DisabledFeature() |
| 1196 | @@ -1658,10 +1563,11 @@ | |||
| 1197 | 1658 | self.calls.append(('addNotSupported', test, feature)) | 1563 | self.calls.append(('addNotSupported', test, feature)) |
| 1198 | 1659 | result = InstrumentedTestResult() | 1564 | result = InstrumentedTestResult() |
| 1199 | 1660 | test.run(result) | 1565 | test.run(result) |
| 1200 | 1566 | case = result.calls[0][1] | ||
| 1201 | 1661 | self.assertEqual([ | 1567 | self.assertEqual([ |
| 1205 | 1662 | ('startTest', test), | 1568 | ('startTest', case), |
| 1206 | 1663 | ('addNotSupported', test, the_feature), | 1569 | ('addNotSupported', case, the_feature), |
| 1207 | 1664 | ('stopTest', test), | 1570 | ('stopTest', case), |
| 1208 | 1665 | ], | 1571 | ], |
| 1209 | 1666 | result.calls) | 1572 | result.calls) |
| 1210 | 1667 | 1573 | ||
| 1211 | @@ -2434,28 +2340,6 @@ | |||
| 1212 | 2434 | self.assertEqual('bzr: interrupted\n', result[1]) | 2340 | self.assertEqual('bzr: interrupted\n', result[1]) |
| 1213 | 2435 | 2341 | ||
| 1214 | 2436 | 2342 | ||
| 1215 | 2437 | class TestKnownFailure(tests.TestCase): | ||
| 1216 | 2438 | |||
| 1217 | 2439 | def test_known_failure(self): | ||
| 1218 | 2440 | """Check that KnownFailure is defined appropriately.""" | ||
| 1219 | 2441 | # a KnownFailure is an assertion error for compatability with unaware | ||
| 1220 | 2442 | # runners. | ||
| 1221 | 2443 | self.assertIsInstance(tests.KnownFailure(""), AssertionError) | ||
| 1222 | 2444 | |||
| 1223 | 2445 | def test_expect_failure(self): | ||
| 1224 | 2446 | try: | ||
| 1225 | 2447 | self.expectFailure("Doomed to failure", self.assertTrue, False) | ||
| 1226 | 2448 | except tests.KnownFailure, e: | ||
| 1227 | 2449 | self.assertEqual('Doomed to failure', e.args[0]) | ||
| 1228 | 2450 | try: | ||
| 1229 | 2451 | self.expectFailure("Doomed to failure", self.assertTrue, True) | ||
| 1230 | 2452 | except AssertionError, e: | ||
| 1231 | 2453 | self.assertEqual('Unexpected success. Should have failed:' | ||
| 1232 | 2454 | ' Doomed to failure', e.args[0]) | ||
| 1233 | 2455 | else: | ||
| 1234 | 2456 | self.fail('Assertion not raised') | ||
| 1235 | 2457 | |||
| 1236 | 2458 | |||
| 1237 | 2459 | class TestFeature(tests.TestCase): | 2343 | class TestFeature(tests.TestCase): |
| 1238 | 2460 | 2344 | ||
| 1239 | 2461 | def test_caching(self): | 2345 | def test_caching(self): |
| 1240 | @@ -2697,8 +2581,7 @@ | |||
| 1241 | 2697 | # the test framework | 2581 | # the test framework |
| 1242 | 2698 | self.assertEquals('always fails', str(e)) | 2582 | self.assertEquals('always fails', str(e)) |
| 1243 | 2699 | # check that there's no traceback in the test log | 2583 | # check that there's no traceback in the test log |
| 1246 | 2700 | self.assertNotContainsRe(self._get_log(keep_log_file=True), | 2584 | self.assertNotContainsRe(self.get_log(), r'Traceback') |
| 1245 | 2701 | r'Traceback') | ||
| 1247 | 2702 | 2585 | ||
| 1248 | 2703 | def test_run_bzr_user_error_caught(self): | 2586 | def test_run_bzr_user_error_caught(self): |
| 1249 | 2704 | # Running bzr in blackbox mode, normal/expected/user errors should be | 2587 | # Running bzr in blackbox mode, normal/expected/user errors should be |
| 1250 | @@ -2957,14 +2840,12 @@ | |||
| 1251 | 2957 | def test_load_tests(self): | 2840 | def test_load_tests(self): |
| 1252 | 2958 | test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing'] | 2841 | test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing'] |
| 1253 | 2959 | loader = self._create_loader(test_list) | 2842 | loader = self._create_loader(test_list) |
| 1254 | 2960 | |||
| 1255 | 2961 | suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler') | 2843 | suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler') |
| 1256 | 2962 | self.assertEquals(test_list, _test_ids(suite)) | 2844 | self.assertEquals(test_list, _test_ids(suite)) |
| 1257 | 2963 | 2845 | ||
| 1258 | 2964 | def test_exclude_tests(self): | 2846 | def test_exclude_tests(self): |
| 1259 | 2965 | test_list = ['bogus'] | 2847 | test_list = ['bogus'] |
| 1260 | 2966 | loader = self._create_loader(test_list) | 2848 | loader = self._create_loader(test_list) |
| 1261 | 2967 | |||
| 1262 | 2968 | suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler') | 2849 | suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler') |
| 1263 | 2969 | self.assertEquals([], _test_ids(suite)) | 2850 | self.assertEquals([], _test_ids(suite)) |
| 1264 | 2970 | 2851 | ||
| 1265 | @@ -3015,8 +2896,8 @@ | |||
| 1266 | 3015 | tpr.register('bar', 'bbb.aaa.rrr') | 2896 | tpr.register('bar', 'bbb.aaa.rrr') |
| 1267 | 3016 | tpr.register('bar', 'bBB.aAA.rRR') | 2897 | tpr.register('bar', 'bBB.aAA.rRR') |
| 1268 | 3017 | self.assertEquals('bbb.aaa.rrr', tpr.get('bar')) | 2898 | self.assertEquals('bbb.aaa.rrr', tpr.get('bar')) |
| 1271 | 3018 | self.assertContainsRe(self._get_log(keep_log_file=True), | 2899 | self.assertThat(self.get_log(), |
| 1272 | 3019 | r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR') | 2900 | DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS)) |
| 1273 | 3020 | 2901 | ||
| 1274 | 3021 | def test_get_unknown_prefix(self): | 2902 | def test_get_unknown_prefix(self): |
| 1275 | 3022 | tpr = self._get_registry() | 2903 | tpr = self._get_registry() |
| 1276 | 3023 | 2904 | ||
| 1277 | === modified file 'bzrlib/tests/test_trace.py' | |||
| 1278 | --- bzrlib/tests/test_trace.py 2009-11-08 19:07:00 +0000 | |||
| 1279 | +++ bzrlib/tests/test_trace.py 2009-12-17 09:43:14 +0000 | |||
| 1280 | @@ -144,21 +144,21 @@ | |||
| 1281 | 144 | def test_trace_unicode(self): | 144 | def test_trace_unicode(self): |
| 1282 | 145 | """Write Unicode to trace log""" | 145 | """Write Unicode to trace log""" |
| 1283 | 146 | self.log(u'the unicode character for benzene is \N{BENZENE RING}') | 146 | self.log(u'the unicode character for benzene is \N{BENZENE RING}') |
| 1286 | 147 | self.assertContainsRe(self._get_log(keep_log_file=True), | 147 | log = self.get_log() |
| 1287 | 148 | "the unicode character for benzene is") | 148 | self.assertContainsRe(log, "the unicode character for benzene is") |
| 1288 | 149 | 149 | ||
| 1289 | 150 | def test_trace_argument_unicode(self): | 150 | def test_trace_argument_unicode(self): |
| 1290 | 151 | """Write a Unicode argument to the trace log""" | 151 | """Write a Unicode argument to the trace log""" |
| 1291 | 152 | mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}') | 152 | mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}') |
| 1294 | 153 | self.assertContainsRe(self._get_log(keep_log_file=True), | 153 | log = self.get_log() |
| 1295 | 154 | 'the unicode character') | 154 | self.assertContainsRe(log, 'the unicode character') |
| 1296 | 155 | 155 | ||
| 1297 | 156 | def test_trace_argument_utf8(self): | 156 | def test_trace_argument_utf8(self): |
| 1298 | 157 | """Write a Unicode argument to the trace log""" | 157 | """Write a Unicode argument to the trace log""" |
| 1299 | 158 | mutter(u'the unicode character for benzene is %s', | 158 | mutter(u'the unicode character for benzene is %s', |
| 1300 | 159 | u'\N{BENZENE RING}'.encode('utf-8')) | 159 | u'\N{BENZENE RING}'.encode('utf-8')) |
| 1303 | 160 | self.assertContainsRe(self._get_log(keep_log_file=True), | 160 | log = self.get_log() |
| 1304 | 161 | 'the unicode character') | 161 | self.assertContainsRe(log, 'the unicode character') |
| 1305 | 162 | 162 | ||
| 1306 | 163 | def test_report_broken_pipe(self): | 163 | def test_report_broken_pipe(self): |
| 1307 | 164 | try: | 164 | try: |
| 1308 | @@ -177,7 +177,7 @@ | |||
| 1309 | 177 | def test_mutter_callsite_1(self): | 177 | def test_mutter_callsite_1(self): |
| 1310 | 178 | """mutter_callsite can capture 1 level of stack frame.""" | 178 | """mutter_callsite can capture 1 level of stack frame.""" |
| 1311 | 179 | mutter_callsite(1, "foo %s", "a string") | 179 | mutter_callsite(1, "foo %s", "a string") |
| 1313 | 180 | log = self._get_log(keep_log_file=True) | 180 | log = self.get_log() |
| 1314 | 181 | # begin with the message | 181 | # begin with the message |
| 1315 | 182 | self.assertLogStartsWith(log, 'foo a string\nCalled from:\n') | 182 | self.assertLogStartsWith(log, 'foo a string\nCalled from:\n') |
| 1316 | 183 | # should show two frame: this frame and the one above | 183 | # should show two frame: this frame and the one above |
| 1317 | @@ -189,7 +189,7 @@ | |||
| 1318 | 189 | def test_mutter_callsite_2(self): | 189 | def test_mutter_callsite_2(self): |
| 1319 | 190 | """mutter_callsite can capture 2 levels of stack frame.""" | 190 | """mutter_callsite can capture 2 levels of stack frame.""" |
| 1320 | 191 | mutter_callsite(2, "foo %s", "a string") | 191 | mutter_callsite(2, "foo %s", "a string") |
| 1322 | 192 | log = self._get_log(keep_log_file=True) | 192 | log = self.get_log() |
| 1323 | 193 | # begin with the message | 193 | # begin with the message |
| 1324 | 194 | self.assertLogStartsWith(log, 'foo a string\nCalled from:\n') | 194 | self.assertLogStartsWith(log, 'foo a string\nCalled from:\n') |
| 1325 | 195 | # should show two frame: this frame and the one above | 195 | # should show two frame: this frame and the one above |
| 1326 | @@ -201,13 +201,19 @@ | |||
| 1327 | 201 | def test_mutter_never_fails(self): | 201 | def test_mutter_never_fails(self): |
| 1328 | 202 | # Even if the decode/encode stage fails, mutter should not | 202 | # Even if the decode/encode stage fails, mutter should not |
| 1329 | 203 | # raise an exception | 203 | # raise an exception |
| 1330 | 204 | # This test checks that mutter doesn't fail; the current behaviour | ||
| 1331 | 205 | # is that it doesn't fail *and writes non-utf8*. | ||
| 1332 | 204 | mutter(u'Writing a greek mu (\xb5) works in a unicode string') | 206 | mutter(u'Writing a greek mu (\xb5) works in a unicode string') |
| 1333 | 205 | mutter('But fails in an ascii string \xb5') | 207 | mutter('But fails in an ascii string \xb5') |
| 1334 | 206 | mutter('and in an ascii argument: %s', '\xb5') | 208 | mutter('and in an ascii argument: %s', '\xb5') |
| 1336 | 207 | log = self._get_log(keep_log_file=True) | 209 | log = self.get_log() |
| 1337 | 208 | self.assertContainsRe(log, 'Writing a greek mu') | 210 | self.assertContainsRe(log, 'Writing a greek mu') |
| 1338 | 209 | self.assertContainsRe(log, "But fails in an ascii string") | 211 | self.assertContainsRe(log, "But fails in an ascii string") |
| 1340 | 210 | self.assertContainsRe(log, u"ascii argument: \xb5") | 212 | # However, the log content object does unicode replacement on reading |
| 1341 | 213 | # to let it get unicode back where good data has been written. So we | ||
| 1342 | 214 | # have to do a replaceent here as well. | ||
| 1343 | 215 | self.assertContainsRe(log, "ascii argument: \xb5".decode('utf8', | ||
| 1344 | 216 | 'replace')) | ||
| 1345 | 211 | 217 | ||
| 1346 | 212 | def test_push_log_file(self): | 218 | def test_push_log_file(self): |
| 1347 | 213 | """Can push and pop log file, and this catches mutter messages. | 219 | """Can push and pop log file, and this catches mutter messages. |
| 1348 | 214 | 220 | ||
| 1349 | === modified file 'bzrlib/tests/test_transport_log.py' | |||
| 1350 | --- bzrlib/tests/test_transport_log.py 2009-07-01 07:04:47 +0000 | |||
| 1351 | +++ bzrlib/tests/test_transport_log.py 2009-12-17 09:43:14 +0000 | |||
| 1352 | @@ -36,10 +36,9 @@ | |||
| 1353 | 36 | # operations such as mkdir are logged | 36 | # operations such as mkdir are logged |
| 1354 | 37 | mutter('where are you?') | 37 | mutter('where are you?') |
| 1355 | 38 | logging_transport.mkdir('subdir') | 38 | logging_transport.mkdir('subdir') |
| 1360 | 39 | self.assertContainsRe(self._get_log(True), | 39 | log = self.get_log() |
| 1361 | 40 | r'mkdir memory\+\d+://.*subdir') | 40 | self.assertContainsRe(log, r'mkdir memory\+\d+://.*subdir') |
| 1362 | 41 | self.assertContainsRe(self._get_log(True), | 41 | self.assertContainsRe(log, ' --> None') |
| 1359 | 42 | ' --> None') | ||
| 1363 | 43 | # they have the expected effect | 42 | # they have the expected effect |
| 1364 | 44 | self.assertTrue(logging_transport.has('subdir')) | 43 | self.assertTrue(logging_transport.has('subdir')) |
| 1365 | 45 | # and they operate on the underlying transport | 44 | # and they operate on the underlying transport |
I'm proposing this branch to get feedback; its not necessarily ripe, though I'd be happy to land it as-is (there aren't any must-do items remaining for it).
This branch deletes a bunch of code:
17 files changed, 180 insertions(+), 350 deletions(-)
It dos this by using testtools as a base class and using the defined extension points there to add bzr specific functionality.
The net effect of doing this:
- bzr selftest --parallel will now show log files, as will --subunit and pqm if we enable subunit there again.
- assertThat is available for bzr to use
- bzr no longer needs an implementation of run(), addCleanup(). There may be more duplicate assertions, but I haven't been on a hunt to minimise the duplication.
testtools 0.10 will be needed (that isn't released yet, but jml wants to bump to -10 when we make run() extensible. I'm putting a branch for that up for review in a few minutes).
-Rob