← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_test_server.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_test_server.py
212
212
 
213
213
        class FailingDuringResponseHandler(TCPConnectionHandler):
214
214
 
215
 
            # We use 'request' instead of 'self' below because the test matters
216
 
            # more and we need a container to properly set connection_thread.
217
215
            def handle_connection(request):
218
216
                req = request.readline()
219
217
                # Capture the thread and make it use 'caught' so we can wait on
220
 
                # the event that will be set when the exception is caught. We
 
218
                # the even that will be set when the exception is caught. We
221
219
                # also capture the thread to know where to look.
222
220
                self.connection_thread = threading.currentThread()
223
221
                self.connection_thread.set_sync_event(caught)
234
232
        # Check that the connection thread did catch the exception,
235
233
        # http://pad.lv/869366 was wrongly checking the server thread which
236
234
        # works for TestingTCPServer where the connection is handled in the
237
 
        # same thread than the server one but was racy for
238
 
        # TestingThreadingTCPServer. Since the connection thread detaches
239
 
        # itself before handling the request, we are guaranteed that the
240
 
        # exception won't leak into the server thread anymore.
241
 
        self.assertRaises(FailToRespond,
242
 
                          self.connection_thread.pending_exception)
 
235
        # same thread than the server one but is racy for
 
236
        # TestingThreadingTCPServer where the server thread may be in a
 
237
        # blocking accept() call (or not).
 
238
        try:
 
239
            self.connection_thread.pending_exception()
 
240
        except FailToRespond:
 
241
            # Great, the test succeeded
 
242
            pass
 
243
        else:
 
244
            # If the exception is not in the connection thread anymore, it's in
 
245
            # the server's one. 
 
246
            server.server.stopped.wait()
 
247
            # The exception is available now
 
248
            self.assertRaises(FailToRespond, server.pending_exception)
243
249
 
244
250
    def test_exception_swallowed_while_serving(self):
245
251
        # We need to ensure the exception has been caught
254
260
 
255
261
        class FailingWhileServingConnectionHandler(TCPConnectionHandler):
256
262
 
257
 
            # We use 'request' instead of 'self' below because the test matters
258
 
            # more and we need a container to properly set connection_thread.
259
263
            def handle(request):
260
264
                # Capture the thread and make it use 'caught' so we can wait on
261
 
                # the event that will be set when the exception is caught. We
 
265
                # the even that will be set when the exception is caught. We
262
266
                # also capture the thread to know where to look.
263
267
                self.connection_thread = threading.currentThread()
264
268
                self.connection_thread.set_sync_event(caught)
266
270
 
267
271
        server = self.get_server(
268
272
            connection_handler_class=FailingWhileServingConnectionHandler)
269
 
        self.assertEquals(True, server.server.serving)
270
273
        # Install the exception swallower
271
274
        server.set_ignored_exceptions(CantServe)
272
275
        client = self.get_client()
281
284
        # here). More precisely, the exception *has* been caught and captured
282
285
        # but it is cleared when joining the thread (or trying to acquire the
283
286
        # exception) and as such won't propagate to the server thread.
284
 
        self.assertIs(None, self.connection_thread.pending_exception())
285
 
        self.assertIs(None, server.pending_exception())
 
287
        self.connection_thread.pending_exception()
 
288
        server.pending_exception()
286
289
 
287
290
    def test_handle_request_closes_if_it_doesnt_process(self):
288
291
        server = self.get_server()