1
=== modified file 'lib/lp/services/job/tests/test_runner.py'
2
--- lib/lp/services/job/tests/test_runner.py	2010-03-09 14:28:11 +0000
3
+++ lib/lp/services/job/tests/test_runner.py	2010-03-11 16:36:43 +0000
4
@@ -27,7 +27,7 @@
5
27
from lp.services.job.model.job import Job
27
from lp.services.job.model.job import Job
6
28
from lp.services.job.runner import (
28
from lp.services.job.runner import (
7
29
    BaseRunnableJob, JobCronScript, JobRunner, TwistedJobRunner)
29
    BaseRunnableJob, JobCronScript, JobRunner, TwistedJobRunner)
9
30
from lp.testing import TestCaseWithFactory, ZopeIsolatedTest
30
from lp.testing import TestCaseWithFactory, ZopeTestInSubProcess
10
31
from lp.testing.mail_helpers import pop_notifications
31
from lp.testing.mail_helpers import pop_notifications
11
32
32
12
33
33
13
@@ -301,7 +301,7 @@
14
301
        self.entries.append(input)
301
        self.entries.append(input)
15
302
302
16
303
303
18
304
class TestTwistedJobRunner(ZopeIsolatedTest, TestCaseWithFactory):
304
class TestTwistedJobRunner(ZopeTestInSubProcess, TestCaseWithFactory):
19
305
305
20
306
    layer = LaunchpadZopelessLayer
306
    layer = LaunchpadZopelessLayer
21
307
307
22
@@ -326,7 +326,7 @@
23
326
        self.assertIn('Job ran too long.', oops.value)
326
        self.assertIn('Job ran too long.', oops.value)
24
327
327
25
328
328
27
329
class TestJobCronScript(ZopeIsolatedTest, TestCaseWithFactory):
329
class TestJobCronScript(ZopeTestInSubProcess, TestCaseWithFactory):
28
330
330
29
331
    layer = LaunchpadZopelessLayer
331
    layer = LaunchpadZopelessLayer
30
332
332
31
333
333
32
=== modified file 'lib/lp/testing/__init__.py'
33
--- lib/lp/testing/__init__.py	2010-03-09 14:28:11 +0000
34
+++ lib/lp/testing/__init__.py	2010-03-11 16:36:43 +0000
35
@@ -29,7 +29,7 @@
36
29
    'validate_mock_class',
29
    'validate_mock_class',
37
30
    'WindmillTestCase',
30
    'WindmillTestCase',
38
31
    'with_anonymous_login',
31
    'with_anonymous_login',
40
32
    'ZopeIsolatedTest',
32
    'ZopeTestInSubProcess',
41
33
    ]
33
    ]
42
34
34
43
35
import copy
35
import copy
44
@@ -590,7 +590,7 @@
45
590
        self.client.open(url=u'http://launchpad.dev:8085')
590
        self.client.open(url=u'http://launchpad.dev:8085')
46
591
591
47
592
592
49
593
class ZopeIsolatedTest:
593
class ZopeTestInSubProcess:
50
594
    """Run tests in a sub-process, respecting Zope idiosyncrasies.
594
    """Run tests in a sub-process, respecting Zope idiosyncrasies.
51
595
595
52
596
    Use this as a mixin with an interesting `TestCase` or `TestSuite`
596
    Use this as a mixin with an interesting `TestCase` or `TestSuite`
53
@@ -631,7 +631,7 @@
54
631
            # obtain the result.
631
            # obtain the result.
55
632
            result = testtools.MultiTestResult(
632
            result = testtools.MultiTestResult(
56
633
                result, subunit.TestProtocolClient(fdwrite))
633
                result, subunit.TestProtocolClient(fdwrite))
58
634
            super(ZopeIsolatedTest, self).run(result)
634
            super(ZopeTestInSubProcess, self).run(result)
59
635
            fdwrite.flush()
635
            fdwrite.flush()
60
636
            sys.stdout.flush()
636
            sys.stdout.flush()
61
637
            sys.stderr.flush()
637
            sys.stderr.flush()
62
638
638
63
=== added file 'lib/lp/testing/tests/test_zope_test_in_subprocess.py'
64
--- lib/lp/testing/tests/test_zope_test_in_subprocess.py	1970-01-01 00:00:00 +0000
65
+++ lib/lp/testing/tests/test_zope_test_in_subprocess.py	2010-03-11 21:36:45 +0000
66
@@ -0,0 +1,118 @@
67
1
# Copyright 2010 Canonical Ltd.  This software is licensed under the
68
2
# GNU Affero General Public License version 3 (see the file LICENSE).
69
3
70
4
"""Test `lp.testing.ZopeTestInSubProcess`."""
71
5
72
6
__metaclass__ = type
73
7
74
8
import functools
75
9
import os
76
10
import unittest
77
11
78
12
from lp.testing import ZopeTestInSubProcess
79
13
80
14
81
15
def record_pid(method):
82
16
    """Decorator that records the pid at method invocation.
83
17
84
18
    Will probably only DTRT with class methods or bound instance
85
19
    methods.
86
20
    """
87
21
    @functools.wraps(method)
88
22
    def wrapper(self, *args, **kwargs):
89
23
        setattr(self, 'pid_in_%s' % method.__name__, os.getpid())
90
24
        return method(self, *args, **kwargs)
91
25
    return wrapper
92
26
93
27
94
28
class TestZopeTestInSubProcessLayer:
95
29
    """Helper to test `ZopeTestInSubProcess`.
96
30
97
31
    Asserts that layers are set up and torn down in the expected way,
98
32
    namely that setUp() and tearDown() are called in the parent
99
33
    process, and testSetUp() and testTearDown() are called in the
100
34
    child process.
101
35
102
36
    The assertions for tearDown() and testTearDown() must be done here
103
37
    because the test case runs before these methods are called. In the
104
38
    interests of symmetry and clarity, the assertions for setUp() and
105
39
    testSetUp() are done here too.
106
40
    """
107
41
108
42
    @record_pid
109
43
    def __init__(self, test):
110
44
        self.test = test
111
45
        # These are needed to satisfy the requirements of the
112
46
        # byzantine Zope layer machinery.
113
47
        self.__name__ = self.__class__.__name__
114
48
        self.__bases__ = self.__class__.__bases__
115
49
116
50
    @record_pid
117
51
    def setUp(self):
118
52
        # Runs in the parent process.
119
53
        assert self.pid_in___init__ == self.pid_in_setUp, (
120
54
            "layer.setUp() not called in parent process.")
121
55
122
56
    @record_pid
123
57
    def tearDown(self):
124
58
        # Runs in the parent process.
125
59
        assert self.pid_in___init__ == self.pid_in_tearDown, (
126
60
            "layer.tearDown() not called in parent process.")
127
61
128
62
    @record_pid
129
63
    def testSetUp(self):
130
64
        # Runs in the child process.
131
65
        assert self.pid_in___init__ != self.pid_in_testSetUp, (
132
66
            "layer.testSetUp() called in parent process.")
133
67
134
68
    @record_pid
135
69
    def testTearDown(self):
136
70
        # Runs in the child process.
137
71
        assert self.pid_in_testSetUp == self.pid_in_testTearDown, (
138
72
            "layer.testTearDown() not called in same process as testSetUp().")
139
73
140
74
141
75
class TestZopeTestInSubProcess(ZopeTestInSubProcess, unittest.TestCase):
142
76
    """Test `ZopeTestInSubProcess`.
143
77
144
78
    Assert that setUp(), test() and tearDown() are called in the child
145
79
    process.
146
80
    """
147
81
148
82
    @record_pid
149
83
    def __init__(self, method_name='runTest'):
150
84
        # Runs in the parent process.
151
85
        super(TestZopeTestInSubProcess, self).__init__(method_name)
152
86
        self.layer = TestZopeTestInSubProcessLayer(self)
153
87
154
88
    @record_pid
155
89
    def setUp(self):
156
90
        # Runs in the child process.
157
91
        super(TestZopeTestInSubProcess, self).setUp()
158
92
        self.failUnlessEqual(
159
93
            self.layer.pid_in_testSetUp, self.pid_in_setUp,
160
94
            "setUp() not called in same process as layer.testSetUp().")
161
95
162
96
    @record_pid
163
97
    def test(self):
164
98
        # Runs in the child process.
165
99
        self.failUnlessEqual(
166
100
            self.pid_in_setUp, self.pid_in_test,
167
101
            "test method not run in same process as setUp().")
168
102
169
103
    @record_pid
170
104
    def tearDown(self):
171
105
        # Runs in the child process.
172
106
        super(TestZopeTestInSubProcess, self).tearDown()
173
107
        self.failUnlessEqual(
174
108
            self.pid_in_setUp, self.pid_in_tearDown,
175
109
            "tearDown() not run in same process as setUp().")
176
110
177
111
178
112
def test_suite():
179
113
    suite = unittest.TestSuite()
180
114
    loader = unittest.TestLoader()
181
115
    suite.addTests(
182
116
        loader.loadTestsFromTestCase(
183
117
            TestZopeTestInSubProcess))
184
118
    return suite
1
=== modified file 'lib/lp/testing/__init__.py'
2
--- lib/lp/testing/__init__.py	2010-03-11 16:37:22 +0000
3
+++ lib/lp/testing/__init__.py	2010-03-12 10:58:17 +0000
4
@@ -593,22 +593,12 @@
5
593
class ZopeTestInSubProcess:
593
class ZopeTestInSubProcess:
6
594
    """Run tests in a sub-process, respecting Zope idiosyncrasies.
594
    """Run tests in a sub-process, respecting Zope idiosyncrasies.
7
595
595
24
596
    Use this as a mixin with an interesting `TestCase` or `TestSuite`
596
    Use this as a mixin with an interesting `TestCase` to isolate
25
597
    subclass to quickly isolate tests with side-effects.
597
    tests with side-effects. Each and every test *method* in the test
26
598
598
    case is run in a new, forked, sub-process. This will slow down
27
599
    When mixed-in with a `TestCase`:
599
    your tests, so use it sparingly. However, when you need to, for
28
600
600
    example, start the Twisted reactor (which cannot currently be
29
601
      Each and every test *method* in the test case is run in a new,
601
    safely stopped and restarted in process) it is invaluable.
14
602
      forked, sub-process. This will slow down your tests, so use it
15
603
      sparingly. However, when you need to, for example, start the
16
604
      Twisted reactor (which cannot currently be safely stopped and
17
605
      restarted in process) it is invaluable.
18
606
19
607
    When mixed-in with a `TestSuite`:
20
608
21
609
      All tests in this suite are run in a single, newly forked,
22
610
      sub-process. This isolates the parent process from side-effects,
23
611
      but the tests in this suite are not isolated from one another.
30
612
602
31
613
    This is basically a reimplementation of subunit's
603
    This is basically a reimplementation of subunit's
32
614
    `IsolatedTestCase` or `IsolatedTestSuite`, but adjusted to work
604
    `IsolatedTestCase` or `IsolatedTestSuite`, but adjusted to work
33
615
605
34
=== modified file 'lib/lp/testing/tests/test_zope_test_in_subprocess.py'
35
--- lib/lp/testing/tests/test_zope_test_in_subprocess.py	2010-03-11 21:37:41 +0000
36
+++ lib/lp/testing/tests/test_zope_test_in_subprocess.py	2010-03-15 11:46:49 +0000
37
@@ -1,7 +1,18 @@
38
1
# Copyright 2010 Canonical Ltd.  This software is licensed under the
1
# Copyright 2010 Canonical Ltd.  This software is licensed under the
39
2
# GNU Affero General Public License version 3 (see the file LICENSE).
2
# GNU Affero General Public License version 3 (see the file LICENSE).
40
3
3
42
4
"""Test `lp.testing.ZopeTestInSubProcess`."""
4
"""Test `lp.testing.ZopeTestInSubProcess`.
43
5
44
6
How does it do this?
45
7
46
8
A `TestCase`, mixed-in with `ZopeTestInSubProcess`, is run by the Zope
47
9
test runner. This test case sets its own layer, to keep track of the
48
10
PIDs when certain methods are called. It also records pids for its own
49
11
methods. Assertions are made as these methods are called to ensure that
50
12
they are running in the correct process - the parent or the child.
51
13
52
14
Recording of the PIDs is handled using the `record_pid` decorator.
53
15
"""
54
5
16
55
6
__metaclass__ = type
17
__metaclass__ = type
56
7
18
57
@@ -37,11 +48,13 @@
58
37
    because the test case runs before these methods are called. In the
48
    because the test case runs before these methods are called. In the
59
38
    interests of symmetry and clarity, the assertions for setUp() and
49
    interests of symmetry and clarity, the assertions for setUp() and
60
39
    testSetUp() are done here too.
50
    testSetUp() are done here too.
61
51
62
52
    This layer expects to be *instantiated*, which is not the norm for
63
53
    Zope layers. See `TestZopeTestInSubProcess` for its use.
64
40
    """
54
    """
65
41
55
66
42
    @record_pid
56
    @record_pid
69
43
    def __init__(self, test):
57
    def __init__(self):
68
44
        self.test = test
70
45
        # These are needed to satisfy the requirements of the
58
        # These are needed to satisfy the requirements of the
71
46
        # byzantine Zope layer machinery.
59
        # byzantine Zope layer machinery.
72
47
        self.__name__ = self.__class__.__name__
60
        self.__name__ = self.__class__.__name__
73
@@ -54,12 +67,6 @@
74
54
            "layer.setUp() not called in parent process.")
67
            "layer.setUp() not called in parent process.")
75
55
68
76
56
    @record_pid
69
    @record_pid
77
57
    def tearDown(self):
78
58
        # Runs in the parent process.
79
59
        assert self.pid_in___init__ == self.pid_in_tearDown, (
80
60
            "layer.tearDown() not called in parent process.")
81
61
82
62
    @record_pid
83
63
    def testSetUp(self):
70
    def testSetUp(self):
84
64
        # Runs in the child process.
71
        # Runs in the child process.
85
65
        assert self.pid_in___init__ != self.pid_in_testSetUp, (
72
        assert self.pid_in___init__ != self.pid_in_testSetUp, (
86
@@ -71,19 +78,30 @@
87
71
        assert self.pid_in_testSetUp == self.pid_in_testTearDown, (
78
        assert self.pid_in_testSetUp == self.pid_in_testTearDown, (
88
72
            "layer.testTearDown() not called in same process as testSetUp().")
79
            "layer.testTearDown() not called in same process as testSetUp().")
89
73
80
90
81
    @record_pid
91
82
    def tearDown(self):
92
83
        # Runs in the parent process.
93
84
        assert self.pid_in___init__ == self.pid_in_tearDown, (
94
85
            "layer.tearDown() not called in parent process.")
95
86
96
74
87
97
75
class TestZopeTestInSubProcess(ZopeTestInSubProcess, unittest.TestCase):
88
class TestZopeTestInSubProcess(ZopeTestInSubProcess, unittest.TestCase):
98
76
    """Test `ZopeTestInSubProcess`.
89
    """Test `ZopeTestInSubProcess`.
99
77
90
100
78
    Assert that setUp(), test() and tearDown() are called in the child
91
    Assert that setUp(), test() and tearDown() are called in the child
101
79
    process.
92
    process.
102
93
103
94
    Sets its own layer attribute. This layer is then responsible for
104
95
    recording the PID at interesting moments. Specifically,
105
96
    layer.testSetUp() must be called in the same process as
106
97
    test.setUp().
107
80
    """
98
    """
108
81
99
109
82
    @record_pid
100
    @record_pid
110
83
    def __init__(self, method_name='runTest'):
101
    def __init__(self, method_name='runTest'):
111
84
        # Runs in the parent process.
102
        # Runs in the parent process.
112
85
        super(TestZopeTestInSubProcess, self).__init__(method_name)
103
        super(TestZopeTestInSubProcess, self).__init__(method_name)
114
86
        self.layer = TestZopeTestInSubProcessLayer(self)
104
        self.layer = TestZopeTestInSubProcessLayer()
115
87
105
116
88
    @record_pid
106
    @record_pid
117
89
    def setUp(self):
107
    def setUp(self):
118
@@ -110,9 +128,4 @@
119
110
128
120
111
129
121
112
def test_suite():
130
def test_suite():
128
113
    suite = unittest.TestSuite()
131
    return unittest.TestLoader().loadTestsFromName(__name__)
123
114
    loader = unittest.TestLoader()
124
115
    suite.addTests(
125
116
        loader.loadTestsFromTestCase(
126
117
            TestZopeTestInSubProcess))
127
118
    return suite
1
=== modified file 'lib/lp/services/job/runner.py'
2
--- lib/lp/services/job/runner.py	2010-02-25 12:07:15 +0000
3
+++ lib/lp/services/job/runner.py	2010-03-16 18:02:40 +0000
4
@@ -401,9 +401,10 @@
5
401
class JobCronScript(LaunchpadCronScript):
401
class JobCronScript(LaunchpadCronScript):
6
402
    """Base class for scripts that run jobs."""
402
    """Base class for scripts that run jobs."""
7
403
403
9
404
    def __init__(self, runner_class=JobRunner):
404
    def __init__(self, runner_class=JobRunner, test_args=None):
10
405
        self.dbuser = getattr(config, self.config_name).dbuser
405
        self.dbuser = getattr(config, self.config_name).dbuser
12
406
        super(JobCronScript, self).__init__(self.config_name, self.dbuser)
406
        super(JobCronScript, self).__init__(
13
407
            self.config_name, self.dbuser, test_args)
14
407
        self.runner_class = runner_class
408
        self.runner_class = runner_class
15
408
409
16
409
    def main(self):
410
    def main(self):
17
410
411
18
=== modified file 'lib/lp/services/job/tests/test_runner.py'
19
--- lib/lp/services/job/tests/test_runner.py	2010-02-24 19:52:01 +0000
20
+++ lib/lp/services/job/tests/test_runner.py	2010-03-16 18:02:40 +0000
21
@@ -11,23 +11,24 @@
22
11
from unittest import TestLoader
11
from unittest import TestLoader
23
12
12
24
13
import transaction
13
import transaction
26
14
from canonical.testing import LaunchpadZopelessLayer
14
27
15
from zope.component import getUtility
15
from zope.component import getUtility
28
16
from zope.error.interfaces import IErrorReportingUtility
16
from zope.error.interfaces import IErrorReportingUtility
29
17
from zope.interface import implements
17
from zope.interface import implements
30
18
18
31
19
from canonical.launchpad.webapp import errorlog
32
20
from canonical.launchpad.webapp.interfaces import (
33
21
    DEFAULT_FLAVOR, IStoreSelector, MAIN_STORE)
34
22
from canonical.testing import LaunchpadZopelessLayer
35
23
36
19
from lp.code.interfaces.branchmergeproposal import (
24
from lp.code.interfaces.branchmergeproposal import (
42
20
    IUpdatePreviewDiffJobSource,)
25
    IUpdatePreviewDiffJobSource)
38
21
from lp.testing.mail_helpers import pop_notifications
39
22
from lp.services.job.runner import (
40
23
    JobCronScript, JobRunner, BaseRunnableJob, TwistedJobRunner
41
24
)
43
25
from lp.services.job.interfaces.job import JobStatus, IRunnableJob
26
from lp.services.job.interfaces.job import JobStatus, IRunnableJob
44
26
from lp.services.job.model.job import Job
27
from lp.services.job.model.job import Job
49
27
from lp.testing import TestCaseWithFactory
28
from lp.services.job.runner import (
50
28
from canonical.launchpad.webapp import errorlog
29
    BaseRunnableJob, JobCronScript, JobRunner, TwistedJobRunner)
51
29
from canonical.launchpad.webapp.interfaces import (
30
from lp.testing import TestCaseWithFactory, ZopeTestInSubProcess
52
30
    IStoreSelector, MAIN_STORE, DEFAULT_FLAVOR)
31
from lp.testing.mail_helpers import pop_notifications
53
31
32
54
32
33
55
33
class NullJob(BaseRunnableJob):
34
class NullJob(BaseRunnableJob):
56
@@ -300,7 +301,7 @@
57
300
        self.entries.append(input)
301
        self.entries.append(input)
58
301
302
59
302
303
61
303
class TestTwistedJobRunner(TestCaseWithFactory):
304
class TestTwistedJobRunner(ZopeTestInSubProcess, TestCaseWithFactory):
62
304
305
63
305
    layer = LaunchpadZopelessLayer
306
    layer = LaunchpadZopelessLayer
64
306
307
65
@@ -325,7 +326,7 @@
66
325
        self.assertIn('Job ran too long.', oops.value)
326
        self.assertIn('Job ran too long.', oops.value)
67
326
327
68
327
328
70
328
class TestJobCronScript(TestCaseWithFactory):
329
class TestJobCronScript(ZopeTestInSubProcess, TestCaseWithFactory):
71
329
330
72
330
    layer = LaunchpadZopelessLayer
331
    layer = LaunchpadZopelessLayer
73
331
332
74
@@ -351,7 +352,8 @@
75
351
            source_interface = IUpdatePreviewDiffJobSource
352
            source_interface = IUpdatePreviewDiffJobSource
76
352
353
77
353
            def __init__(self):
354
            def __init__(self):
79
354
                super(JobCronScriptSubclass, self).__init__(DummyRunner)
355
                super(JobCronScriptSubclass, self).__init__(
80
356
                    DummyRunner, test_args=[])
81
355
                self.logger = ListLogger()
357
                self.logger = ListLogger()
82
356
358
83
357
        old_errorlog = errorlog.globalErrorUtility
359
        old_errorlog = errorlog.globalErrorUtility
84
358
360
85
=== modified file 'lib/lp/testing/__init__.py'
86
--- lib/lp/testing/__init__.py	2010-03-01 03:06:02 +0000
87
+++ lib/lp/testing/__init__.py	2010-03-16 18:02:40 +0000
88
@@ -29,6 +29,7 @@
89
29
    'validate_mock_class',
29
    'validate_mock_class',
90
30
    'WindmillTestCase',
30
    'WindmillTestCase',
91
31
    'with_anonymous_login',
31
    'with_anonymous_login',
92
32
    'ZopeTestInSubProcess',
93
32
    ]
33
    ]
94
33
34
95
34
import copy
35
import copy
96
@@ -38,6 +39,8 @@
97
38
from pprint import pformat
39
from pprint import pformat
98
39
import shutil
40
import shutil
99
40
import subprocess
41
import subprocess
100
42
import subunit
101
43
import sys
102
41
import tempfile
44
import tempfile
103
42
import time
45
import time
104
43
46
105
@@ -62,6 +65,7 @@
106
62
from zope.interface.verify import verifyClass, verifyObject
65
from zope.interface.verify import verifyClass, verifyObject
107
63
from zope.security.proxy import (
66
from zope.security.proxy import (
108
64
    isinstance as zope_isinstance, removeSecurityProxy)
67
    isinstance as zope_isinstance, removeSecurityProxy)
109
68
from zope.testing.testrunner.runner import TestResult as ZopeTestResult
110
65
69
111
66
from canonical.launchpad.webapp import errorlog
70
from canonical.launchpad.webapp import errorlog
112
67
from canonical.config import config
71
from canonical.config import config
113
@@ -586,6 +590,70 @@
114
586
        self.client.open(url=u'http://launchpad.dev:8085')
590
        self.client.open(url=u'http://launchpad.dev:8085')
115
587
591
116
588
592
117
593
class ZopeTestInSubProcess:
118
594
    """Run tests in a sub-process, respecting Zope idiosyncrasies.
119
595
120
596
    Use this as a mixin with an interesting `TestCase` to isolate
121
597
    tests with side-effects. Each and every test *method* in the test
122
598
    case is run in a new, forked, sub-process. This will slow down
123
599
    your tests, so use it sparingly. However, when you need to, for
124
600
    example, start the Twisted reactor (which cannot currently be
125
601
    safely stopped and restarted in process) it is invaluable.
126
602
127
603
    This is basically a reimplementation of subunit's
128
604
    `IsolatedTestCase` or `IsolatedTestSuite`, but adjusted to work
129
605
    with Zope. In particular, Zope's TestResult object is responsible
130
606
    for calling testSetUp() and testTearDown() on the selected layer.
131
607
    """
132
608
133
609
    def run(self, result):
134
610
        # The result must be an instance of Zope's TestResult because
135
611
        # we construct a super() of it later on. Other result classes
136
612
        # could be supported with a more general approach, but it's
137
613
        # unlikely that any one approach is going to work for every
138
614
        # class. It's better to fail early and draw attention here.
139
615
        assert isinstance(result, ZopeTestResult), (
140
616
            "result must be a Zope result object, not %r." % (result,))
141
617
        pread, pwrite = os.pipe()
142
618
        pid = os.fork()
143
619
        if pid == 0:
144
620
            # Child.
145
621
            os.close(pread)
146
622
            fdwrite = os.fdopen(pwrite, 'w', 1)
147
623
            # Send results to both the Zope result object (so that
148
624
            # layer setup and teardown are done properly, etc.) and to
149
625
            # the subunit stream client so that the parent process can
150
626
            # obtain the result.
151
627
            result = testtools.MultiTestResult(
152
628
                result, subunit.TestProtocolClient(fdwrite))
153
629
            super(ZopeTestInSubProcess, self).run(result)
154
630
            fdwrite.flush()
155
631
            sys.stdout.flush()
156
632
            sys.stderr.flush()
157
633
            # Exit hard to avoid running onexit handlers and to avoid
158
634
            # anything that could suppress SystemExit; this exit must
159
635
            # not be prevented.
160
636
            os._exit(0)
161
637
        else:
162
638
            # Parent.
163
639
            os.close(pwrite)
164
640
            fdread = os.fdopen(pread, 'rU')
165
641
            # Skip all the Zope-specific result stuff by using a
166
642
            # super() of the result. This is because the Zope result
167
643
            # object calls testSetUp() and testTearDown() on the
168
644
            # layer, and handles post-mortem debugging. These things
169
645
            # do not make sense in the parent process. More
170
646
            # immediately, it also means that the results are not
171
647
            # reported twice; they are reported on stdout by the child
172
648
            # process, so they need to be suppressed here.
173
649
            result = super(ZopeTestResult, result)
174
650
            # Accept the result from the child process.
175
651
            protocol = subunit.TestProtocolServer(result)
176
652
            protocol.readFrom(fdread)
177
653
            fdread.close()
178
654
            os.waitpid(pid, 0)
179
655
180
656
181
589
def capture_events(callable_obj, *args, **kwargs):
657
def capture_events(callable_obj, *args, **kwargs):
182
590
    """Capture the events emitted by a callable.
658
    """Capture the events emitted by a callable.
183
591
659
184
592
660
185
=== added file 'lib/lp/testing/tests/test_zope_test_in_subprocess.py'
186
--- lib/lp/testing/tests/test_zope_test_in_subprocess.py	1970-01-01 00:00:00 +0000
187
+++ lib/lp/testing/tests/test_zope_test_in_subprocess.py	2010-03-16 18:02:40 +0000
188
@@ -0,0 +1,131 @@
189
1
# Copyright 2010 Canonical Ltd.  This software is licensed under the
190
2
# GNU Affero General Public License version 3 (see the file LICENSE).
191
3
192
4
"""Test `lp.testing.ZopeTestInSubProcess`.
193
5
194
6
How does it do this?
195
7
196
8
A `TestCase`, mixed-in with `ZopeTestInSubProcess`, is run by the Zope
197
9
test runner. This test case sets its own layer, to keep track of the
198
10
PIDs when certain methods are called. It also records pids for its own
199
11
methods. Assertions are made as these methods are called to ensure that
200
12
they are running in the correct process - the parent or the child.
201
13
202
14
Recording of the PIDs is handled using the `record_pid` decorator.
203
15
"""
204
16
205
17
__metaclass__ = type
206
18
207
19
import functools
208
20
import os
209
21
import unittest
210
22
211
23
from lp.testing import ZopeTestInSubProcess
212
24
213
25
214
26
def record_pid(method):
215
27
    """Decorator that records the pid at method invocation.
216
28
217
29
    Will probably only DTRT with class methods or bound instance
218
30
    methods.
219
31
    """
220
32
    @functools.wraps(method)
221
33
    def wrapper(self, *args, **kwargs):
222
34
        setattr(self, 'pid_in_%s' % method.__name__, os.getpid())
223
35
        return method(self, *args, **kwargs)
224
36
    return wrapper
225
37
226
38
227
39
class TestZopeTestInSubProcessLayer:
228
40
    """Helper to test `ZopeTestInSubProcess`.
229
41
230
42
    Asserts that layers are set up and torn down in the expected way,
231
43
    namely that setUp() and tearDown() are called in the parent
232
44
    process, and testSetUp() and testTearDown() are called in the
233
45
    child process.
234
46
235
47
    The assertions for tearDown() and testTearDown() must be done here
236
48
    because the test case runs before these methods are called. In the
237
49
    interests of symmetry and clarity, the assertions for setUp() and
238
50
    testSetUp() are done here too.
239
51
240
52
    This layer expects to be *instantiated*, which is not the norm for
241
53
    Zope layers. See `TestZopeTestInSubProcess` for its use.
242
54
    """
243
55
244
56
    @record_pid
245
57
    def __init__(self):
246
58
        # These are needed to satisfy the requirements of the
247
59
        # byzantine Zope layer machinery.
248
60
        self.__name__ = self.__class__.__name__
249
61
        self.__bases__ = self.__class__.__bases__
250
62
251
63
    @record_pid
252
64
    def setUp(self):
253
65
        # Runs in the parent process.
254
66
        assert self.pid_in___init__ == self.pid_in_setUp, (
255
67
            "layer.setUp() not called in parent process.")
256
68
257
69
    @record_pid
258
70
    def testSetUp(self):
259
71
        # Runs in the child process.
260
72
        assert self.pid_in___init__ != self.pid_in_testSetUp, (
261
73
            "layer.testSetUp() called in parent process.")
262
74
263
75
    @record_pid
264
76
    def testTearDown(self):
265
77
        # Runs in the child process.
266
78
        assert self.pid_in_testSetUp == self.pid_in_testTearDown, (
267
79
            "layer.testTearDown() not called in same process as testSetUp().")
268
80
269
81
    @record_pid
270
82
    def tearDown(self):
271
83
        # Runs in the parent process.
272
84
        assert self.pid_in___init__ == self.pid_in_tearDown, (
273
85
            "layer.tearDown() not called in parent process.")
274
86
275
87
276
88
class TestZopeTestInSubProcess(ZopeTestInSubProcess, unittest.TestCase):
277
89
    """Test `ZopeTestInSubProcess`.
278
90
279
91
    Assert that setUp(), test() and tearDown() are called in the child
280
92
    process.
281
93
282
94
    Sets its own layer attribute. This layer is then responsible for
283
95
    recording the PID at interesting moments. Specifically,
284
96
    layer.testSetUp() must be called in the same process as
285
97
    test.setUp().
286
98
    """
287
99
288
100
    @record_pid
289
101
    def __init__(self, method_name='runTest'):
290
102
        # Runs in the parent process.
291
103
        super(TestZopeTestInSubProcess, self).__init__(method_name)
292
104
        self.layer = TestZopeTestInSubProcessLayer()
293
105
294
106
    @record_pid
295
107
    def setUp(self):
296
108
        # Runs in the child process.
297
109
        super(TestZopeTestInSubProcess, self).setUp()
298
110
        self.failUnlessEqual(
299
111
            self.layer.pid_in_testSetUp, self.pid_in_setUp,
300
112
            "setUp() not called in same process as layer.testSetUp().")
301
113
302
114
    @record_pid
303
115
    def test(self):
304
116
        # Runs in the child process.
305
117
        self.failUnlessEqual(
306
118
            self.pid_in_setUp, self.pid_in_test,
307
119
            "test method not run in same process as setUp().")
308
120
309
121
    @record_pid
310
122
    def tearDown(self):
311
123
        # Runs in the child process.
312
124
        super(TestZopeTestInSubProcess, self).tearDown()
313
125
        self.failUnlessEqual(
314
126
            self.pid_in_setUp, self.pid_in_tearDown,
315
127
            "tearDown() not run in same process as setUp().")
316
128
317
129
318
130
def test_suite():
319
131
    return unittest.TestLoader().loadTestsFromName(__name__)
Reviewer	Date Requested	Status
Jonathan Lange (community)		Approve on 2010-03-16
Björn Tillenius (community)	2010-03-08	Abstain on 2010-03-12
Review via email: mp+20916@code.launchpad.net