Merge lp:~jml/launchpad/one-email-on-crash into lp:launchpad
- one-email-on-crash
- Merge into devel
Proposed by
Jonathan Lange
| Status: | Merged |
|---|---|
| Approved by: | Jonathan Lange |
| Approved revision: | no longer in the source branch. |
| Merged at revision: | 11455 |
| Proposed branch: | lp:~jml/launchpad/one-email-on-crash |
| Merge into: | lp:launchpad |
| Prerequisite: | lp:~jml/launchpad/launchpad-tester |
| Diff against target: |
547 lines (+199/-60) 2 files modified
lib/devscripts/ec2test/remote.py (+34/-15) lib/devscripts/ec2test/tests/test_remote.py (+165/-45) |
| To merge this branch: | bzr merge lp:~jml/launchpad/one-email-on-crash |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Michael Nelson (community) | code | Approve | |
|
Review via email:
|
|||
Commit message
Only send one email when "ec2 test" fails catastrophically.
Description of the change
ec2 test has a fair bit of stuff in it to make sure that unexpected failures
don't screw things up too badly, and that appropriate folk get told about it.
Unfortunately, in the code currently in Launchpad, there's perhaps a bit too
much redundancy and safety. This code changes things so that you get exactly
one email if ec2 test fails surprisingly.
The reason I wanted to make this change is to:
a) clarify, test and document the way we send email on failure.
b) create separate interfaces for sending email on catastrophe vs normal
test results
c) reduce the amount of email I receive ever so slightly
Landing this branch will make it possible, finally, to free the normal
test email from the shackles of displaying the actual output of the test
runner.
In terms of code changes:
* Refactor EC2Runner & LaunchpadTester to take an SMTPConnection object
and use that for sending mail, thus allowing for easier testing of
what mail gets sent.
* Change WebTestLogger.
rather than got_result.
* Change LaunchpadTester
running the tests. Note: I'm not sure what the reason was for doing so
in the first place.
Thanks,
jml
To post a comment you must log in.
Revision history for this message
| Jonathan Lange (jml) wrote : | # |
Download full text (5.9 KiB)
On Thu, Aug 26, 2010 at 3:13 PM, Michael Nelson
<email address hidden> wrote:
> Review: Approve code
> It would have been nice if the email handling could simply be a logging
> configuration using:
>
> http://
>
> but afaics, that doesn't handle attachments for emails.
>
> Anyway, r=me, with some typos fixed below.
>
>> === modified file 'lib/devscripts
>> --- lib/devscripts/
>> +++ lib/devscripts/
>> @@ -510,6 +519,13 @@
>> summary.
>> traceback.
>> summary.flush()
>> + if self._request.
>> + self._write_
>> + self._summary_
>> + '\n(See the attached file for the complete log)\n')
>> + summary = self.get_
>> + full_log_gz = gzip_data(
>> + self._request.
>
> Is it worth reordering the args to send_report_email, so you could instead
> write:
> self._request.
> summary, full_log_gz, successful=False)
>
> Probably not. I just had to look back to see what was False, but it's obvious
> in retrospect :)
>
I won't do it in this branch, for the reasons you give here. I plan a
follow-up branch that will probably change the API & behaviour a bit,
since it would be nice if the subject for "failed tests" is noticeably
different to the subject for "something went horribly wrong".
>> === modified file 'lib/devscripts
>> --- lib/devscripts/
>> +++ lib/devscripts/
>> @@ -60,7 +71,7 @@
>>
>> def make_request(self, branch_url=None, revno=None,
>> trunk=None, sourcecode_
>> - emails=None, pqm_message=None):
>> + emails=None, pqm_message=None, emails_sent=None):
>> """Make a request to test, specifying only things we care about.
>>
>> Note that the returned request object will not ever send email, but
>
> The above comment needs updating with your change.
>
Done.
>> @@ -94,6 +106,13 @@
>> tree.commit(
>> return 'sourcecode/'
>>
>> + def make_tester(self, logger=None, test_directory=
>> + if not logger:
>> + logger = self.make_logger()
>> + if not test_directory:
>> + test_directory = 'unspecified-
>
> why is test_directory optional? If set it like this, I would have assumed
> that Popen() would fail when it tries to change into this directory?
>
> I haven't tried it, but from the docs:
>
> If cwd is not None, the child’s current directory will be changed to cwd
> before it is executed.
>
> [1] http://
>
> We discus...
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'lib/devscripts/ec2test/remote.py' | |||
| 2 | --- lib/devscripts/ec2test/remote.py 2010-08-24 17:35:55 +0000 | |||
| 3 | +++ lib/devscripts/ec2test/remote.py 2010-08-26 12:56:33 +0000 | |||
| 4 | @@ -40,11 +40,12 @@ | |||
| 5 | 40 | 40 | ||
| 6 | 41 | import bzrlib.branch | 41 | import bzrlib.branch |
| 7 | 42 | import bzrlib.config | 42 | import bzrlib.config |
| 8 | 43 | import bzrlib.email_message | ||
| 9 | 44 | import bzrlib.errors | 43 | import bzrlib.errors |
| 10 | 45 | import bzrlib.smtp_connection | ||
| 11 | 46 | import bzrlib.workingtree | 44 | import bzrlib.workingtree |
| 12 | 47 | 45 | ||
| 13 | 46 | from bzrlib.email_message import EmailMessage | ||
| 14 | 47 | from bzrlib.smtp_connection import SMTPConnection | ||
| 15 | 48 | |||
| 16 | 48 | import subunit | 49 | import subunit |
| 17 | 49 | 50 | ||
| 18 | 50 | 51 | ||
| 19 | @@ -134,19 +135,24 @@ | |||
| 20 | 134 | SHUTDOWN_DELAY = 60 | 135 | SHUTDOWN_DELAY = 60 |
| 21 | 135 | 136 | ||
| 22 | 136 | def __init__(self, daemonize, pid_filename, shutdown_when_done, | 137 | def __init__(self, daemonize, pid_filename, shutdown_when_done, |
| 24 | 137 | emails=None): | 138 | smtp_connection=None, emails=None): |
| 25 | 138 | """Make an EC2Runner. | 139 | """Make an EC2Runner. |
| 26 | 139 | 140 | ||
| 27 | 140 | :param daemonize: Whether or not we will daemonize. | 141 | :param daemonize: Whether or not we will daemonize. |
| 28 | 141 | :param pid_filename: The filename to store the pid in. | 142 | :param pid_filename: The filename to store the pid in. |
| 29 | 142 | :param shutdown_when_done: Whether or not to shut down when the tests | 143 | :param shutdown_when_done: Whether or not to shut down when the tests |
| 30 | 143 | are done. | 144 | are done. |
| 31 | 145 | :param smtp_connection: The `SMTPConnection` to use to send email. | ||
| 32 | 144 | :param emails: The email address(es) to send catastrophic failure | 146 | :param emails: The email address(es) to send catastrophic failure |
| 33 | 145 | messages to. If not provided, the error disappears into the ether. | 147 | messages to. If not provided, the error disappears into the ether. |
| 34 | 146 | """ | 148 | """ |
| 35 | 147 | self._should_daemonize = daemonize | 149 | self._should_daemonize = daemonize |
| 36 | 148 | self._pid_filename = pid_filename | 150 | self._pid_filename = pid_filename |
| 37 | 149 | self._shutdown_when_done = shutdown_when_done | 151 | self._shutdown_when_done = shutdown_when_done |
| 38 | 152 | if smtp_connection is None: | ||
| 39 | 153 | config = bzrlib.config.GlobalConfig() | ||
| 40 | 154 | smtp_connection = SMTPConnection(config) | ||
| 41 | 155 | self._smtp_connection = smtp_connection | ||
| 42 | 150 | self._emails = emails | 156 | self._emails = emails |
| 43 | 151 | self._daemonized = False | 157 | self._daemonized = False |
| 44 | 152 | 158 | ||
| 45 | @@ -188,10 +194,12 @@ | |||
| 46 | 188 | config = bzrlib.config.GlobalConfig() | 194 | config = bzrlib.config.GlobalConfig() |
| 47 | 189 | # Handle exceptions thrown by the test() or daemonize() methods. | 195 | # Handle exceptions thrown by the test() or daemonize() methods. |
| 48 | 190 | if self._emails: | 196 | if self._emails: |
| 53 | 191 | bzrlib.email_message.EmailMessage.send( | 197 | msg = EmailMessage( |
| 54 | 192 | config, config.username(), | 198 | from_address=config.username(), |
| 55 | 193 | self._emails, '%s FAILED' % (name,), | 199 | to_address=self._emails, |
| 56 | 194 | traceback.format_exc()) | 200 | subject='%s FAILED' % (name,), |
| 57 | 201 | body=traceback.format_exc()) | ||
| 58 | 202 | self._smtp_connection.send_email(msg) | ||
| 59 | 195 | raise | 203 | raise |
| 60 | 196 | finally: | 204 | finally: |
| 61 | 197 | # When everything is over, if we've been ask to shut down, then | 205 | # When everything is over, if we've been ask to shut down, then |
| 62 | @@ -267,9 +275,7 @@ | |||
| 63 | 267 | exit_status = popen.wait() | 275 | exit_status = popen.wait() |
| 64 | 268 | except: | 276 | except: |
| 65 | 269 | self._logger.error_in_testrunner(sys.exc_info()) | 277 | self._logger.error_in_testrunner(sys.exc_info()) |
| 69 | 270 | exit_status = 1 | 278 | else: |
| 67 | 271 | raise | ||
| 68 | 272 | finally: | ||
| 70 | 273 | self._logger.got_result(not exit_status) | 279 | self._logger.got_result(not exit_status) |
| 71 | 274 | 280 | ||
| 72 | 275 | def _gather_test_output(self, input_stream, logger): | 281 | def _gather_test_output(self, input_stream, logger): |
| 73 | @@ -287,7 +293,7 @@ | |||
| 74 | 287 | """A request to have a branch tested and maybe landed.""" | 293 | """A request to have a branch tested and maybe landed.""" |
| 75 | 288 | 294 | ||
| 76 | 289 | def __init__(self, branch_url, revno, local_branch_path, sourcecode_path, | 295 | def __init__(self, branch_url, revno, local_branch_path, sourcecode_path, |
| 78 | 290 | emails=None, pqm_message=None): | 296 | emails=None, pqm_message=None, smtp_connection=None): |
| 79 | 291 | """Construct a `Request`. | 297 | """Construct a `Request`. |
| 80 | 292 | 298 | ||
| 81 | 293 | :param branch_url: The public URL to the Launchpad branch we are | 299 | :param branch_url: The public URL to the Launchpad branch we are |
| 82 | @@ -303,6 +309,7 @@ | |||
| 83 | 303 | provided, no emails are sent. | 309 | provided, no emails are sent. |
| 84 | 304 | :param pqm_message: The message to submit to PQM. If not provided, we | 310 | :param pqm_message: The message to submit to PQM. If not provided, we |
| 85 | 305 | don't submit to PQM. | 311 | don't submit to PQM. |
| 86 | 312 | :param smtp_connection: The `SMTPConnection` to use to send email. | ||
| 87 | 306 | """ | 313 | """ |
| 88 | 307 | self._branch_url = branch_url | 314 | self._branch_url = branch_url |
| 89 | 308 | self._revno = revno | 315 | self._revno = revno |
| 90 | @@ -312,11 +319,13 @@ | |||
| 91 | 312 | self._pqm_message = pqm_message | 319 | self._pqm_message = pqm_message |
| 92 | 313 | # Used for figuring out how to send emails. | 320 | # Used for figuring out how to send emails. |
| 93 | 314 | self._bzr_config = bzrlib.config.GlobalConfig() | 321 | self._bzr_config = bzrlib.config.GlobalConfig() |
| 94 | 322 | if smtp_connection is None: | ||
| 95 | 323 | smtp_connection = SMTPConnection(self._bzr_config) | ||
| 96 | 324 | self._smtp_connection = smtp_connection | ||
| 97 | 315 | 325 | ||
| 98 | 316 | def _send_email(self, message): | 326 | def _send_email(self, message): |
| 99 | 317 | """Actually send 'message'.""" | 327 | """Actually send 'message'.""" |
| 102 | 318 | conn = bzrlib.smtp_connection.SMTPConnection(self._bzr_config) | 328 | self._smtp_connection.send_email(message) |
| 101 | 319 | conn.send_email(message) | ||
| 103 | 320 | 329 | ||
| 104 | 321 | def get_target_details(self): | 330 | def get_target_details(self): |
| 105 | 322 | """Return (branch_url, revno) for trunk.""" | 331 | """Return (branch_url, revno) for trunk.""" |
| 106 | @@ -510,6 +519,13 @@ | |||
| 107 | 510 | summary.write('\n\nERROR IN TESTRUNNER\n\n') | 519 | summary.write('\n\nERROR IN TESTRUNNER\n\n') |
| 108 | 511 | traceback.print_exception(exc_type, exc_value, exc_tb, file=summary) | 520 | traceback.print_exception(exc_type, exc_value, exc_tb, file=summary) |
| 109 | 512 | summary.flush() | 521 | summary.flush() |
| 110 | 522 | if self._request.wants_email: | ||
| 111 | 523 | self._write_to_filename( | ||
| 112 | 524 | self._summary_filename, | ||
| 113 | 525 | '\n(See the attached file for the complete log)\n') | ||
| 114 | 526 | summary = self.get_summary_contents() | ||
| 115 | 527 | full_log_gz = gzip_data(self.get_full_log_contents()) | ||
| 116 | 528 | self._request.send_report_email(False, summary, full_log_gz) | ||
| 117 | 513 | 529 | ||
| 118 | 514 | def get_index_contents(self): | 530 | def get_index_contents(self): |
| 119 | 515 | """Return the contents of the index.html page.""" | 531 | """Return the contents of the index.html page.""" |
| 120 | @@ -805,16 +821,19 @@ | |||
| 121 | 805 | 821 | ||
| 122 | 806 | pid_filename = os.path.join(LAUNCHPAD_DIR, 'ec2test-remote.pid') | 822 | pid_filename = os.path.join(LAUNCHPAD_DIR, 'ec2test-remote.pid') |
| 123 | 807 | 823 | ||
| 124 | 824 | smtp_connection = SMTPConnection(bzrlib.config.GlobalConfig()) | ||
| 125 | 825 | |||
| 126 | 808 | request = Request( | 826 | request = Request( |
| 127 | 809 | options.public_branch, options.public_branch_revno, TEST_DIR, | 827 | options.public_branch, options.public_branch_revno, TEST_DIR, |
| 129 | 810 | SOURCECODE_DIR, options.email, pqm_message) | 828 | SOURCECODE_DIR, options.email, pqm_message, smtp_connection) |
| 130 | 811 | # Only write to stdout if we are running as the foreground process. | 829 | # Only write to stdout if we are running as the foreground process. |
| 131 | 812 | echo_to_stdout = not options.daemon | 830 | echo_to_stdout = not options.daemon |
| 132 | 813 | logger = WebTestLogger.make_in_directory( | 831 | logger = WebTestLogger.make_in_directory( |
| 133 | 814 | '/var/www', request, echo_to_stdout) | 832 | '/var/www', request, echo_to_stdout) |
| 134 | 815 | 833 | ||
| 135 | 816 | runner = EC2Runner( | 834 | runner = EC2Runner( |
| 137 | 817 | options.daemon, pid_filename, options.shutdown, options.email) | 835 | options.daemon, pid_filename, options.shutdown, |
| 138 | 836 | smtp_connection, options.email) | ||
| 139 | 818 | 837 | ||
| 140 | 819 | tester = LaunchpadTester(logger, TEST_DIR, test_options=args[1:]) | 838 | tester = LaunchpadTester(logger, TEST_DIR, test_options=args[1:]) |
| 141 | 820 | runner.run("Test runner", tester.test) | 839 | runner.run("Test runner", tester.test) |
| 142 | 821 | 840 | ||
| 143 | === modified file 'lib/devscripts/ec2test/tests/test_remote.py' | |||
| 144 | --- lib/devscripts/ec2test/tests/test_remote.py 2010-08-24 17:44:22 +0000 | |||
| 145 | +++ lib/devscripts/ec2test/tests/test_remote.py 2010-08-26 12:56:33 +0000 | |||
| 146 | @@ -26,6 +26,7 @@ | |||
| 147 | 26 | from testtools.content_type import ContentType | 26 | from testtools.content_type import ContentType |
| 148 | 27 | 27 | ||
| 149 | 28 | from devscripts.ec2test.remote import ( | 28 | from devscripts.ec2test.remote import ( |
| 150 | 29 | EC2Runner, | ||
| 151 | 29 | FlagFallStream, | 30 | FlagFallStream, |
| 152 | 30 | gunzip_data, | 31 | gunzip_data, |
| 153 | 31 | gzip_data, | 32 | gzip_data, |
| 154 | @@ -38,6 +39,16 @@ | |||
| 155 | 38 | ) | 39 | ) |
| 156 | 39 | 40 | ||
| 157 | 40 | 41 | ||
| 158 | 42 | class LoggingSMTPConnection(object): | ||
| 159 | 43 | """An SMTPConnection double that logs sent email.""" | ||
| 160 | 44 | |||
| 161 | 45 | def __init__(self, log): | ||
| 162 | 46 | self._log = log | ||
| 163 | 47 | |||
| 164 | 48 | def send_email(self, message): | ||
| 165 | 49 | self._log.append(message) | ||
| 166 | 50 | |||
| 167 | 51 | |||
| 168 | 41 | class RequestHelpers: | 52 | class RequestHelpers: |
| 169 | 42 | 53 | ||
| 170 | 43 | def patch(self, obj, name, value): | 54 | def patch(self, obj, name, value): |
| 171 | @@ -60,7 +71,7 @@ | |||
| 172 | 60 | 71 | ||
| 173 | 61 | def make_request(self, branch_url=None, revno=None, | 72 | def make_request(self, branch_url=None, revno=None, |
| 174 | 62 | trunk=None, sourcecode_path=None, | 73 | trunk=None, sourcecode_path=None, |
| 176 | 63 | emails=None, pqm_message=None): | 74 | emails=None, pqm_message=None, emails_sent=None): |
| 177 | 64 | """Make a request to test, specifying only things we care about. | 75 | """Make a request to test, specifying only things we care about. |
| 178 | 65 | 76 | ||
| 179 | 66 | Note that the returned request object will not ever send email, but | 77 | Note that the returned request object will not ever send email, but |
| 180 | @@ -73,11 +84,12 @@ | |||
| 181 | 73 | [('a', 'http://example.com/bzr/a', 2), | 84 | [('a', 'http://example.com/bzr/a', 2), |
| 182 | 74 | ('b', 'http://example.com/bzr/b', 3), | 85 | ('b', 'http://example.com/bzr/b', 3), |
| 183 | 75 | ('c', 'http://example.com/bzr/c', 5)]) | 86 | ('c', 'http://example.com/bzr/c', 5)]) |
| 184 | 87 | if emails_sent is None: | ||
| 185 | 88 | emails_sent = [] | ||
| 186 | 89 | smtp_connection = LoggingSMTPConnection(emails_sent) | ||
| 187 | 76 | request = Request( | 90 | request = Request( |
| 188 | 77 | branch_url, revno, trunk.basedir, sourcecode_path, emails, | 91 | branch_url, revno, trunk.basedir, sourcecode_path, emails, |
| 192 | 78 | pqm_message) | 92 | pqm_message, smtp_connection) |
| 190 | 79 | request.emails_sent = [] | ||
| 191 | 80 | request._send_email = request.emails_sent.append | ||
| 193 | 81 | return request | 93 | return request |
| 194 | 82 | 94 | ||
| 195 | 83 | def make_sourcecode(self, branches): | 95 | def make_sourcecode(self, branches): |
| 196 | @@ -94,6 +106,13 @@ | |||
| 197 | 94 | tree.commit(message=str(i)) | 106 | tree.commit(message=str(i)) |
| 198 | 95 | return 'sourcecode/' | 107 | return 'sourcecode/' |
| 199 | 96 | 108 | ||
| 200 | 109 | def make_tester(self, logger=None, test_directory=None, test_options=()): | ||
| 201 | 110 | if not logger: | ||
| 202 | 111 | logger = self.make_logger() | ||
| 203 | 112 | if not test_directory: | ||
| 204 | 113 | test_directory = 'unspecified-test-directory' | ||
| 205 | 114 | return LaunchpadTester(logger, test_directory, test_options) | ||
| 206 | 115 | |||
| 207 | 97 | def make_logger(self, request=None, echo_to_stdout=False): | 116 | def make_logger(self, request=None, echo_to_stdout=False): |
| 208 | 98 | if request is None: | 117 | if request is None: |
| 209 | 99 | request = self.make_request() | 118 | request = self.make_request() |
| 210 | @@ -199,13 +218,6 @@ | |||
| 211 | 199 | 218 | ||
| 212 | 200 | class TestLaunchpadTester(TestCaseWithTransport, RequestHelpers): | 219 | class TestLaunchpadTester(TestCaseWithTransport, RequestHelpers): |
| 213 | 201 | 220 | ||
| 214 | 202 | def make_tester(self, logger=None, test_directory=None, test_options=()): | ||
| 215 | 203 | if not logger: | ||
| 216 | 204 | logger = self.make_logger() | ||
| 217 | 205 | if not test_directory: | ||
| 218 | 206 | test_directory = 'unspecified-test-directory' | ||
| 219 | 207 | return LaunchpadTester(logger, test_directory, test_options) | ||
| 220 | 208 | |||
| 221 | 209 | def test_build_test_command_no_options(self): | 221 | def test_build_test_command_no_options(self): |
| 222 | 210 | # The LaunchpadTester runs "make check" if given no options. | 222 | # The LaunchpadTester runs "make check" if given no options. |
| 223 | 211 | tester = self.make_tester() | 223 | tester = self.make_tester() |
| 224 | @@ -243,14 +255,15 @@ | |||
| 225 | 243 | # got_result with the result. This test is more of a smoke test to | 255 | # got_result with the result. This test is more of a smoke test to |
| 226 | 244 | # make sure that everything integrates well. | 256 | # make sure that everything integrates well. |
| 227 | 245 | message = {'Subject': "One Crowded Hour"} | 257 | message = {'Subject': "One Crowded Hour"} |
| 229 | 246 | request = self.make_request(pqm_message=message) | 258 | log = [] |
| 230 | 259 | request = self.make_request(pqm_message=message, emails_sent=log) | ||
| 231 | 247 | logger = self.make_logger(request=request) | 260 | logger = self.make_logger(request=request) |
| 232 | 248 | tester = self.make_tester(logger=logger) | 261 | tester = self.make_tester(logger=logger) |
| 233 | 249 | output = "test output\n" | 262 | output = "test output\n" |
| 234 | 250 | tester._spawn_test_process = lambda: FakePopen(output, 0) | 263 | tester._spawn_test_process = lambda: FakePopen(output, 0) |
| 235 | 251 | tester.test() | 264 | tester.test() |
| 236 | 252 | # Message being sent implies got_result thought it got a success. | 265 | # Message being sent implies got_result thought it got a success. |
| 238 | 253 | self.assertEqual([message], request.emails_sent) | 266 | self.assertEqual([message], log) |
| 239 | 254 | 267 | ||
| 240 | 255 | def test_error_in_testrunner(self): | 268 | def test_error_in_testrunner(self): |
| 241 | 256 | # Any exception is raised within LaunchpadTester.test() is an error in | 269 | # Any exception is raised within LaunchpadTester.test() is an error in |
| 242 | @@ -260,28 +273,30 @@ | |||
| 243 | 260 | # failure. | 273 | # failure. |
| 244 | 261 | # 3. Re-raise the error. In the script, this triggers an email. | 274 | # 3. Re-raise the error. In the script, this triggers an email. |
| 245 | 262 | message = {'Subject': "One Crowded Hour"} | 275 | message = {'Subject': "One Crowded Hour"} |
| 247 | 263 | request = self.make_request(pqm_message=message) | 276 | log = [] |
| 248 | 277 | request = self.make_request(pqm_message=message, emails_sent=log) | ||
| 249 | 264 | logger = self.make_logger(request=request) | 278 | logger = self.make_logger(request=request) |
| 250 | 265 | tester = self.make_tester(logger=logger) | 279 | tester = self.make_tester(logger=logger) |
| 251 | 266 | # Break the test runner deliberately. In production, this is more | 280 | # Break the test runner deliberately. In production, this is more |
| 252 | 267 | # likely to be a system error than a programming error. | 281 | # likely to be a system error than a programming error. |
| 253 | 268 | tester._spawn_test_process = lambda: 1/0 | 282 | tester._spawn_test_process = lambda: 1/0 |
| 255 | 269 | self.assertRaises(ZeroDivisionError, tester.test) | 283 | tester.test() |
| 256 | 270 | # Message not being sent implies got_result thought it got a failure. | 284 | # Message not being sent implies got_result thought it got a failure. |
| 258 | 271 | self.assertEqual([], request.emails_sent) | 285 | self.assertEqual([], log) |
| 259 | 272 | self.assertIn("ERROR IN TESTRUNNER", logger.get_summary_contents()) | 286 | self.assertIn("ERROR IN TESTRUNNER", logger.get_summary_contents()) |
| 260 | 273 | self.assertIn("ZeroDivisionError", logger.get_summary_contents()) | 287 | self.assertIn("ZeroDivisionError", logger.get_summary_contents()) |
| 261 | 274 | 288 | ||
| 262 | 275 | def test_nonzero_exit_code(self): | 289 | def test_nonzero_exit_code(self): |
| 263 | 276 | message = {'Subject': "One Crowded Hour"} | 290 | message = {'Subject': "One Crowded Hour"} |
| 265 | 277 | request = self.make_request(pqm_message=message) | 291 | log = [] |
| 266 | 292 | request = self.make_request(pqm_message=message, emails_sent=log) | ||
| 267 | 278 | logger = self.make_logger(request=request) | 293 | logger = self.make_logger(request=request) |
| 268 | 279 | tester = self.make_tester(logger=logger) | 294 | tester = self.make_tester(logger=logger) |
| 269 | 280 | output = "test output\n" | 295 | output = "test output\n" |
| 270 | 281 | tester._spawn_test_process = lambda: FakePopen(output, 10) | 296 | tester._spawn_test_process = lambda: FakePopen(output, 10) |
| 271 | 282 | tester.test() | 297 | tester.test() |
| 272 | 283 | # Message not being sent implies got_result thought it got a failure. | 298 | # Message not being sent implies got_result thought it got a failure. |
| 274 | 284 | self.assertEqual([], request.emails_sent) | 299 | self.assertEqual([], log) |
| 275 | 285 | 300 | ||
| 276 | 286 | 301 | ||
| 277 | 287 | class TestPidfileHelpers(TestCase): | 302 | class TestPidfileHelpers(TestCase): |
| 278 | @@ -449,9 +464,10 @@ | |||
| 279 | 449 | 464 | ||
| 280 | 450 | def test_submit_to_pqm_no_message_doesnt_send(self): | 465 | def test_submit_to_pqm_no_message_doesnt_send(self): |
| 281 | 451 | # If there's no PQM message, then 'submit_to_pqm' returns None. | 466 | # If there's no PQM message, then 'submit_to_pqm' returns None. |
| 283 | 452 | req = self.make_request(pqm_message=None) | 467 | log = [] |
| 284 | 468 | req = self.make_request(pqm_message=None, emails_sent=log) | ||
| 285 | 453 | req.submit_to_pqm(successful=True) | 469 | req.submit_to_pqm(successful=True) |
| 287 | 454 | self.assertEqual([], req.emails_sent) | 470 | self.assertEqual([], log) |
| 288 | 455 | 471 | ||
| 289 | 456 | def test_submit_to_pqm_unsuccessful(self): | 472 | def test_submit_to_pqm_unsuccessful(self): |
| 290 | 457 | # submit_to_pqm returns the subject of the PQM mail even if it's | 473 | # submit_to_pqm returns the subject of the PQM mail even if it's |
| 291 | @@ -464,17 +480,19 @@ | |||
| 292 | 464 | def test_submit_to_pqm_unsuccessful_no_email(self): | 480 | def test_submit_to_pqm_unsuccessful_no_email(self): |
| 293 | 465 | # submit_to_pqm doesn't send any email if the run was unsuccessful. | 481 | # submit_to_pqm doesn't send any email if the run was unsuccessful. |
| 294 | 466 | message = {'Subject:': 'My PQM message'} | 482 | message = {'Subject:': 'My PQM message'} |
| 296 | 467 | req = self.make_request(pqm_message=message) | 483 | log = [] |
| 297 | 484 | req = self.make_request(pqm_message=message, emails_sent=log) | ||
| 298 | 468 | req.submit_to_pqm(successful=False) | 485 | req.submit_to_pqm(successful=False) |
| 300 | 469 | self.assertEqual([], req.emails_sent) | 486 | self.assertEqual([], log) |
| 301 | 470 | 487 | ||
| 302 | 471 | def test_submit_to_pqm_successful(self): | 488 | def test_submit_to_pqm_successful(self): |
| 303 | 472 | # submit_to_pqm returns the subject of the PQM mail. | 489 | # submit_to_pqm returns the subject of the PQM mail. |
| 304 | 473 | message = {'Subject:': 'My PQM message'} | 490 | message = {'Subject:': 'My PQM message'} |
| 306 | 474 | req = self.make_request(pqm_message=message) | 491 | log = [] |
| 307 | 492 | req = self.make_request(pqm_message=message, emails_sent=log) | ||
| 308 | 475 | subject = req.submit_to_pqm(successful=True) | 493 | subject = req.submit_to_pqm(successful=True) |
| 309 | 476 | self.assertIs(message.get('Subject'), subject) | 494 | self.assertIs(message.get('Subject'), subject) |
| 311 | 477 | self.assertEqual([message], req.emails_sent) | 495 | self.assertEqual([message], log) |
| 312 | 478 | 496 | ||
| 313 | 479 | def test_report_email_subject_success(self): | 497 | def test_report_email_subject_success(self): |
| 314 | 480 | req = self.make_request(emails=['foo@example.com']) | 498 | req = self.make_request(emails=['foo@example.com']) |
| 315 | @@ -523,10 +541,11 @@ | |||
| 316 | 523 | "gobbledygook", attachment.get_payload().decode('base64')) | 541 | "gobbledygook", attachment.get_payload().decode('base64')) |
| 317 | 524 | 542 | ||
| 318 | 525 | def test_send_report_email_sends_email(self): | 543 | def test_send_report_email_sends_email(self): |
| 320 | 526 | req = self.make_request(emails=['foo@example.com']) | 544 | log = [] |
| 321 | 545 | req = self.make_request(emails=['foo@example.com'], emails_sent=log) | ||
| 322 | 527 | expected = req._build_report_email(False, "foo", "gobbledygook") | 546 | expected = req._build_report_email(False, "foo", "gobbledygook") |
| 323 | 528 | req.send_report_email(False, "foo", "gobbledygook") | 547 | req.send_report_email(False, "foo", "gobbledygook") |
| 325 | 529 | [observed] = req.emails_sent | 548 | [observed] = log |
| 326 | 530 | # The standard library sucks. None of the MIME objects have __eq__ | 549 | # The standard library sucks. None of the MIME objects have __eq__ |
| 327 | 531 | # implementations. | 550 | # implementations. |
| 328 | 532 | for expected_part, observed_part in izip( | 551 | for expected_part, observed_part in izip( |
| 329 | @@ -597,7 +616,7 @@ | |||
| 330 | 597 | self.assertEqual('foo\n', logger.get_full_log_contents()) | 616 | self.assertEqual('foo\n', logger.get_full_log_contents()) |
| 331 | 598 | self.assertEqual('foo\n', logger.get_summary_contents()) | 617 | self.assertEqual('foo\n', logger.get_summary_contents()) |
| 332 | 599 | 618 | ||
| 334 | 600 | def test_error_in_testrunner(self): | 619 | def test_error_in_testrunner_logs_to_summary(self): |
| 335 | 601 | # error_in_testrunner logs the traceback to the summary log in a very | 620 | # error_in_testrunner logs the traceback to the summary log in a very |
| 336 | 602 | # prominent way. | 621 | # prominent way. |
| 337 | 603 | try: | 622 | try: |
| 338 | @@ -611,6 +630,93 @@ | |||
| 339 | 611 | "\n\nERROR IN TESTRUNNER\n\n%s" % (stack,), | 630 | "\n\nERROR IN TESTRUNNER\n\n%s" % (stack,), |
| 340 | 612 | logger.get_summary_contents()) | 631 | logger.get_summary_contents()) |
| 341 | 613 | 632 | ||
| 342 | 633 | def test_error_in_testrunner_sends_email(self): | ||
| 343 | 634 | # If email addresses are configurd, error_in_testrunner emails them | ||
| 344 | 635 | # with the failure and the full log. | ||
| 345 | 636 | try: | ||
| 346 | 637 | 1/0 | ||
| 347 | 638 | except ZeroDivisionError: | ||
| 348 | 639 | exc_info = sys.exc_info() | ||
| 349 | 640 | log = [] | ||
| 350 | 641 | request = self.make_request( | ||
| 351 | 642 | emails=['foo@example.com'], emails_sent=log) | ||
| 352 | 643 | logger = self.make_logger(request=request) | ||
| 353 | 644 | logger.error_in_testrunner(exc_info) | ||
| 354 | 645 | [email] = log | ||
| 355 | 646 | self.assertEqual( | ||
| 356 | 647 | 'Test results: %s: FAILURE' % request.get_merge_description(), | ||
| 357 | 648 | email['Subject']) | ||
| 358 | 649 | [body, attachment] = email.get_payload() | ||
| 359 | 650 | self.assertIsInstance(body, MIMEText) | ||
| 360 | 651 | self.assertEqual('inline', body['Content-Disposition']) | ||
| 361 | 652 | self.assertEqual('text/plain; charset="utf-8"', body['Content-Type']) | ||
| 362 | 653 | self.assertEqual( | ||
| 363 | 654 | logger.get_summary_contents(), body.get_payload(decode=True)) | ||
| 364 | 655 | self.assertIsInstance(attachment, MIMEApplication) | ||
| 365 | 656 | self.assertEqual('application/x-gzip', attachment['Content-Type']) | ||
| 366 | 657 | self.assertEqual( | ||
| 367 | 658 | 'attachment;', | ||
| 368 | 659 | attachment['Content-Disposition'][:len('attachment;')]) | ||
| 369 | 660 | self.assertEqual( | ||
| 370 | 661 | logger.get_full_log_contents(), | ||
| 371 | 662 | gunzip_data(attachment.get_payload().decode('base64'))) | ||
| 372 | 663 | |||
| 373 | 664 | |||
| 374 | 665 | class TestEC2Runner(TestCaseWithTransport, RequestHelpers): | ||
| 375 | 666 | |||
| 376 | 667 | def make_ec2runner(self, emails=None, email_log=None): | ||
| 377 | 668 | if email_log is None: | ||
| 378 | 669 | email_log = [] | ||
| 379 | 670 | smtp_connection = LoggingSMTPConnection(email_log) | ||
| 380 | 671 | return EC2Runner( | ||
| 381 | 672 | False, "who-cares.pid", False, smtp_connection, emails=emails) | ||
| 382 | 673 | |||
| 383 | 674 | def test_run(self): | ||
| 384 | 675 | calls = [] | ||
| 385 | 676 | runner = self.make_ec2runner() | ||
| 386 | 677 | runner.run( | ||
| 387 | 678 | "boring test method", | ||
| 388 | 679 | lambda *a, **kw: calls.append((a, kw)), "foo", "bar", baz="qux") | ||
| 389 | 680 | self.assertEqual([(("foo", "bar"), {'baz': 'qux'})], calls) | ||
| 390 | 681 | |||
| 391 | 682 | def test_email_on_failure_no_emails(self): | ||
| 392 | 683 | # If no emails are specified, then no email is sent on failure. | ||
| 393 | 684 | log = [] | ||
| 394 | 685 | runner = self.make_ec2runner(email_log=log) | ||
| 395 | 686 | self.assertRaises( | ||
| 396 | 687 | ZeroDivisionError, runner.run, "failing method", lambda: 1/0) | ||
| 397 | 688 | self.assertEqual([], log) | ||
| 398 | 689 | |||
| 399 | 690 | def test_email_on_failure_some_emails(self): | ||
| 400 | 691 | # If no emails are specified, then no email is sent on failure. | ||
| 401 | 692 | log = [] | ||
| 402 | 693 | runner = self.make_ec2runner( | ||
| 403 | 694 | email_log=log, emails=["foo@example.com"]) | ||
| 404 | 695 | self.assertRaises( | ||
| 405 | 696 | ZeroDivisionError, runner.run, "failing method", lambda: 1/0) | ||
| 406 | 697 | # XXX: Expect this to fail. Fix the test to be more correct. | ||
| 407 | 698 | [message] = log | ||
| 408 | 699 | self.assertEqual('failing method FAILED', message['Subject']) | ||
| 409 | 700 | self.assertEqual('foo@example.com', message['To']) | ||
| 410 | 701 | self.assertIn('ZeroDivisionError', str(message)) | ||
| 411 | 702 | |||
| 412 | 703 | def test_email_with_launchpad_tester_failure(self): | ||
| 413 | 704 | email_log = [] | ||
| 414 | 705 | to_emails = ['foo@example.com'] | ||
| 415 | 706 | request = self.make_request(emails=to_emails, emails_sent=email_log) | ||
| 416 | 707 | logger = self.make_logger(request=request) | ||
| 417 | 708 | tester = self.make_tester(logger=logger) | ||
| 418 | 709 | # Deliberately break 'tester'. A likely failure in production is not | ||
| 419 | 710 | # being able to spawn the child process. | ||
| 420 | 711 | tester._spawn_test_process = lambda: 1/0 | ||
| 421 | 712 | runner = self.make_ec2runner(emails=to_emails, email_log=email_log) | ||
| 422 | 713 | runner.run("launchpad tester", tester.test) | ||
| 423 | 714 | # The primary thing we care about is that email *was* sent. | ||
| 424 | 715 | self.assertNotEqual([], email_log) | ||
| 425 | 716 | [tester_msg] = email_log | ||
| 426 | 717 | self.assertEqual('foo@example.com', tester_msg['To']) | ||
| 427 | 718 | self.assertIn('ZeroDivisionError', str(tester_msg)) | ||
| 428 | 719 | |||
| 429 | 614 | 720 | ||
| 430 | 615 | class TestDaemonizationInteraction(TestCaseWithTransport, RequestHelpers): | 721 | class TestDaemonizationInteraction(TestCaseWithTransport, RequestHelpers): |
| 431 | 616 | 722 | ||
| 432 | @@ -662,59 +768,69 @@ | |||
| 433 | 662 | return email.get_payload()[0].get_payload() | 768 | return email.get_payload()[0].get_payload() |
| 434 | 663 | 769 | ||
| 435 | 664 | def test_success_no_emails(self): | 770 | def test_success_no_emails(self): |
| 437 | 665 | request = self.make_request(emails=[]) | 771 | log = [] |
| 438 | 772 | request = self.make_request(emails=[], emails_sent=log) | ||
| 439 | 666 | logger = self.make_logger(request=request) | 773 | logger = self.make_logger(request=request) |
| 440 | 667 | logger.got_result(True) | 774 | logger.got_result(True) |
| 442 | 668 | self.assertEqual([], request.emails_sent) | 775 | self.assertEqual([], log) |
| 443 | 669 | 776 | ||
| 444 | 670 | def test_failure_no_emails(self): | 777 | def test_failure_no_emails(self): |
| 446 | 671 | request = self.make_request(emails=[]) | 778 | log = [] |
| 447 | 779 | request = self.make_request(emails=[], emails_sent=log) | ||
| 448 | 672 | logger = self.make_logger(request=request) | 780 | logger = self.make_logger(request=request) |
| 449 | 673 | logger.got_result(False) | 781 | logger.got_result(False) |
| 451 | 674 | self.assertEqual([], request.emails_sent) | 782 | self.assertEqual([], log) |
| 452 | 675 | 783 | ||
| 453 | 676 | def test_submits_to_pqm_on_success(self): | 784 | def test_submits_to_pqm_on_success(self): |
| 454 | 785 | log = [] | ||
| 455 | 677 | message = {'Subject': 'foo'} | 786 | message = {'Subject': 'foo'} |
| 457 | 678 | request = self.make_request(emails=[], pqm_message=message) | 787 | request = self.make_request( |
| 458 | 788 | emails=[], pqm_message=message, emails_sent=log) | ||
| 459 | 679 | logger = self.make_logger(request=request) | 789 | logger = self.make_logger(request=request) |
| 460 | 680 | logger.got_result(True) | 790 | logger.got_result(True) |
| 462 | 681 | self.assertEqual([message], request.emails_sent) | 791 | self.assertEqual([message], log) |
| 463 | 682 | 792 | ||
| 464 | 683 | def test_records_pqm_submission_in_email(self): | 793 | def test_records_pqm_submission_in_email(self): |
| 465 | 794 | log = [] | ||
| 466 | 684 | message = {'Subject': 'foo'} | 795 | message = {'Subject': 'foo'} |
| 467 | 685 | request = self.make_request( | 796 | request = self.make_request( |
| 469 | 686 | emails=['foo@example.com'], pqm_message=message) | 797 | emails=['foo@example.com'], pqm_message=message, emails_sent=log) |
| 470 | 687 | logger = self.make_logger(request=request) | 798 | logger = self.make_logger(request=request) |
| 471 | 688 | logger.got_result(True) | 799 | logger.got_result(True) |
| 473 | 689 | [pqm_message, user_message] = request.emails_sent | 800 | [pqm_message, user_message] = log |
| 474 | 690 | self.assertEqual(message, pqm_message) | 801 | self.assertEqual(message, pqm_message) |
| 475 | 691 | self.assertIn( | 802 | self.assertIn( |
| 476 | 692 | 'SUBMITTED TO PQM:\n%s' % (message['Subject'],), | 803 | 'SUBMITTED TO PQM:\n%s' % (message['Subject'],), |
| 477 | 693 | self.get_body_text(user_message)) | 804 | self.get_body_text(user_message)) |
| 478 | 694 | 805 | ||
| 479 | 695 | def test_doesnt_submit_to_pqm_no_failure(self): | 806 | def test_doesnt_submit_to_pqm_no_failure(self): |
| 480 | 807 | log = [] | ||
| 481 | 696 | message = {'Subject': 'foo'} | 808 | message = {'Subject': 'foo'} |
| 483 | 697 | request = self.make_request(emails=[], pqm_message=message) | 809 | request = self.make_request( |
| 484 | 810 | emails=[], pqm_message=message, emails_sent=log) | ||
| 485 | 698 | logger = self.make_logger(request=request) | 811 | logger = self.make_logger(request=request) |
| 486 | 699 | logger.got_result(False) | 812 | logger.got_result(False) |
| 488 | 700 | self.assertEqual([], request.emails_sent) | 813 | self.assertEqual([], log) |
| 489 | 701 | 814 | ||
| 490 | 702 | def test_records_non_pqm_submission_in_email(self): | 815 | def test_records_non_pqm_submission_in_email(self): |
| 491 | 816 | log = [] | ||
| 492 | 703 | message = {'Subject': 'foo'} | 817 | message = {'Subject': 'foo'} |
| 493 | 704 | request = self.make_request( | 818 | request = self.make_request( |
| 495 | 705 | emails=['foo@example.com'], pqm_message=message) | 819 | emails=['foo@example.com'], pqm_message=message, emails_sent=log) |
| 496 | 706 | logger = self.make_logger(request=request) | 820 | logger = self.make_logger(request=request) |
| 497 | 707 | logger.got_result(False) | 821 | logger.got_result(False) |
| 499 | 708 | [user_message] = request.emails_sent | 822 | [user_message] = log |
| 500 | 709 | self.assertIn( | 823 | self.assertIn( |
| 501 | 710 | '**NOT** submitted to PQM:\n%s' % (message['Subject'],), | 824 | '**NOT** submitted to PQM:\n%s' % (message['Subject'],), |
| 502 | 711 | self.get_body_text(user_message)) | 825 | self.get_body_text(user_message)) |
| 503 | 712 | 826 | ||
| 504 | 713 | def test_email_refers_to_attached_log(self): | 827 | def test_email_refers_to_attached_log(self): |
| 506 | 714 | request = self.make_request(emails=['foo@example.com']) | 828 | log = [] |
| 507 | 829 | request = self.make_request( | ||
| 508 | 830 | emails=['foo@example.com'], emails_sent=log) | ||
| 509 | 715 | logger = self.make_logger(request=request) | 831 | logger = self.make_logger(request=request) |
| 510 | 716 | logger.got_result(False) | 832 | logger.got_result(False) |
| 512 | 717 | [user_message] = request.emails_sent | 833 | [user_message] = log |
| 513 | 718 | self.assertIn( | 834 | self.assertIn( |
| 514 | 719 | '(See the attached file for the complete log)\n', | 835 | '(See the attached file for the complete log)\n', |
| 515 | 720 | self.get_body_text(user_message)) | 836 | self.get_body_text(user_message)) |
| 516 | @@ -726,23 +842,27 @@ | |||
| 517 | 726 | # now and can vary independently from the contents of the sent | 842 | # now and can vary independently from the contents of the sent |
| 518 | 727 | # email. We probably just want the contents of the email to be a list | 843 | # email. We probably just want the contents of the email to be a list |
| 519 | 728 | # of failing tests. | 844 | # of failing tests. |
| 521 | 729 | request = self.make_request(emails=['foo@example.com']) | 845 | log = [] |
| 522 | 846 | request = self.make_request( | ||
| 523 | 847 | emails=['foo@example.com'], emails_sent=log) | ||
| 524 | 730 | logger = self.make_logger(request=request) | 848 | logger = self.make_logger(request=request) |
| 525 | 731 | logger.get_summary_stream().write('bar\nbaz\nqux\n') | 849 | logger.get_summary_stream().write('bar\nbaz\nqux\n') |
| 526 | 732 | logger.got_result(False) | 850 | logger.got_result(False) |
| 528 | 733 | [user_message] = request.emails_sent | 851 | [user_message] = log |
| 529 | 734 | self.assertEqual( | 852 | self.assertEqual( |
| 530 | 735 | 'bar\nbaz\nqux\n\n(See the attached file for the complete log)\n', | 853 | 'bar\nbaz\nqux\n\n(See the attached file for the complete log)\n', |
| 531 | 736 | self.get_body_text(user_message)) | 854 | self.get_body_text(user_message)) |
| 532 | 737 | 855 | ||
| 533 | 738 | def test_gzip_of_full_log_attached(self): | 856 | def test_gzip_of_full_log_attached(self): |
| 534 | 739 | # The full log is attached to the email. | 857 | # The full log is attached to the email. |
| 536 | 740 | request = self.make_request(emails=['foo@example.com']) | 858 | log = [] |
| 537 | 859 | request = self.make_request( | ||
| 538 | 860 | emails=['foo@example.com'], emails_sent=log) | ||
| 539 | 741 | logger = self.make_logger(request=request) | 861 | logger = self.make_logger(request=request) |
| 540 | 742 | logger.got_line("output from test process\n") | 862 | logger.got_line("output from test process\n") |
| 541 | 743 | logger.got_line("more output\n") | 863 | logger.got_line("more output\n") |
| 542 | 744 | logger.got_result(False) | 864 | logger.got_result(False) |
| 544 | 745 | [user_message] = request.emails_sent | 865 | [user_message] = log |
| 545 | 746 | [body, attachment] = user_message.get_payload() | 866 | [body, attachment] = user_message.get_payload() |
| 546 | 747 | self.assertEqual('application/x-gzip', attachment['Content-Type']) | 867 | self.assertEqual('application/x-gzip', attachment['Content-Type']) |
| 547 | 748 | self.assertEqual( | 868 | self.assertEqual( |
It would have been nice if the email handling could simply be a logging
configuration using:
http://
but afaics, that doesn't handle attachments for emails.
Anyway, r=me, with some typos fixed below.
> === modified file 'lib/devscripts
> --- lib/devscripts/
> +++ lib/devscripts/
> @@ -510,6 +519,13 @@
> summary.
> traceback.
> summary.flush()
> + if self._request.
> + self._write_
> + self._summary_
> + '\n(See the attached file for the complete log)\n')
> + summary = self.get_
> + full_log_gz = gzip_data(
> + self._request.
Is it worth reordering the args to send_report_email, so you could instead
write:
Probably not. I just had to look back to see what was False, but it's obvious
in retrospect :)
> === modified file 'lib/devscripts
> --- lib/devscripts/
> +++ lib/devscripts/
> @@ -60,7 +71,7 @@
>
> def make_request(self, branch_url=None, revno=None,
> trunk=None, sourcecode_
> - emails=None, pqm_message=None):
> + emails=None, pqm_message=None, emails_sent=None):
> """Make a request to test, specifying only things we care about.
>
> Note that the returned request object will not ever send email, but
The above comment needs updating with your change.
> @@ -94,6 +106,13 @@
> tree.commit(
> return 'sourcecode/'
>
> + def make_tester(self, logger=None, test_directory=
> + if not logger:
> + logger = self.make_logger()
> + if not test_directory:
> + test_directory = 'unspecified-
why is test_directory optional? If set it like this, I would have assumed
that Popen() would fail when it tries to change into this directory?
I haven't tried it, but from the docs:
If cwd is not None, the child’s current directory will be changed to cwd
before it is executed.
[1] http://
We discussed this:
15:51 < noodles775> jml: why do you set test_directory when it's passed as None?
15:52 < noodles775> (that is, why do you set it to a non-existent directory)
15:52 < jml> noodles775, umm, not sure. maybe because stuff explodes.
15:52 * jml tries.
15:53 < noodles775> According to the docs, I'd assume it wouldn't explode when its None, but will in its current state?
15:53 < noodles775> But yes, science is the best answer :)
15:54 < salgado> thanks for the reviews, noodles775
1...