Merge pull request #53 from jadkik/fix_liveserver_process_termination

Fix liveserver process termination

Author: nicoddemus

docs/changelog.rst

@@ -10,7 +10,15 @@ Next Release
 - Add new ``--live-server-port`` option to select the port the live server will use (`#82`_).
   Thanks `@RazerM`_ for the PR.
 
+- Now ``live_server`` will try to stop the server cleanly by emitting a ``SIGINT`` signal and
+  waiting 5 seconds for the server to shutdown. If the server is still running after 5 seconds,
+  it will be forcefully terminated. This behavior can be changed by passing
+  ``--no-live-server-clean-stop`` in the command-line (`#49`_).
+  Thanks `@jadkik`_ for the PR.
+
+.. _@jadkik: https://github.com/jadkik
 .. _@RazerM: https://github.com/RazerM
+.. _#49: https://github.com/pytest-dev/pytest-flask/issues/49
 .. _#82: https://github.com/pytest-dev/pytest-flask/pull/82
 
 

pytest_flask/fixtures.py

@@ -4,6 +4,9 @@
 import multiprocessing
 import pytest
 import socket
+import signal
+import os
+import logging
 
 try:
     from urllib2 import URLError, urlopen
@@ -50,9 +53,10 @@ class LiveServer(object):
     :param port: The port to run application.
     """
 
-    def __init__(self, app, port):
+    def __init__(self, app, port, clean_stop=False):
         self.app = app
         self.port = port
+        self.clean_stop = clean_stop
         self._process = None
 
     def start(self):
@@ -83,7 +87,25 @@ def url(self, url=''):
     def stop(self):
         """Stop application process."""
         if self._process:
-            self._process.terminate()
+            if self.clean_stop and self._stop_cleanly():
+                return
+            if self._process.is_alive():
+                # If it's still alive, kill it
+                self._process.terminate()
+
+    def _stop_cleanly(self, timeout=5):
+        """Attempts to stop the server cleanly by sending a SIGINT signal and waiting for
+        ``timeout`` seconds.
+
+        :return: True if the server was cleanly stopped, False otherwise.
+        """
+        try:
+            os.kill(self._process.pid, signal.SIGINT)
+            self._process.join(timeout)
+            return True
+        except Exception as ex:
+            logging.error('Failed to join the live server process: %r', ex)
+            return False
 
     def __repr__(self):
         return '<LiveServer listening at %s>' % self.url()
@@ -127,7 +149,8 @@ def test_server_is_up_and_running(live_server):
     monkeypatch.setitem(app.config, 'SERVER_NAME',
                         _rewrite_server_name(server_name, str(port)))
 
-    server = LiveServer(app, port)
+    clean_stop = request.config.getvalue('live_server_clean_stop')
+    server = LiveServer(app, port, clean_stop)
     if request.config.getvalue('start_live_server'):
         server.start()
 

pytest_flask/plugin.py

@@ -124,6 +124,12 @@ def pytest_addoption(parser):
                     action="store_false", dest="start_live_server",
                     help="don't start server automatically when live_server "
                          "fixture is applied.")
+    group.addoption('--live-server-clean-stop',
+                    action="store_true", dest="live_server_clean_stop", default=True,
+                    help="attempt to kill the live server cleanly.")
+    group.addoption('--no-live-server-clean-stop',
+                    action="store_false", dest="live_server_clean_stop",
+                    help="terminate the server forcefully after stop.")
     group.addoption('--live-server-port', action='store', default=0, type=int,
                     help='use a fixed port for the live_server fixture.')
 

tests/test_live_server.py

@@ -67,6 +67,55 @@ def test_a(live_server):
         result.stdout.fnmatch_lines(['*PASSED*'])
         assert result.ret == 0
 
+    @pytest.mark.parametrize('clean_stop', [True, False])
+    def test_clean_stop_live_server(self, appdir, monkeypatch, clean_stop):
+        """Ensure the fixture is trying to cleanly stop the server.
+
+        Because this is tricky to test, we are checking that the _stop_cleanly() internal
+        function was called and reported success.
+        """
+        from pytest_flask.fixtures import LiveServer
+
+        original_stop_cleanly_func = LiveServer._stop_cleanly
+
+        stop_cleanly_result = []
+
+        def mocked_stop_cleanly(*args, **kwargs):
+            result = original_stop_cleanly_func(*args, **kwargs)
+            stop_cleanly_result.append(result)
+            return result
+
+        monkeypatch.setattr(LiveServer, '_stop_cleanly', mocked_stop_cleanly)
+
+        appdir.create_test_module('''
+            import pytest
+            try:
+                from urllib2 import urlopen
+            except ImportError:
+                from urllib.request import urlopen
+
+            from flask import url_for
+
+            def test_a(live_server):
+                @live_server.app.route('/')
+                def index():
+                    return 'got it', 200
+
+                live_server.start()
+
+                res = urlopen(url_for('index', _external=True))
+                assert res.code == 200
+                assert b'got it' in res.read()
+        ''')
+        args = [] if clean_stop else ['--no-live-server-clean-stop']
+        result = appdir.runpytest_inprocess('-v', '--no-start-live-server',
+                                            *args)
+        result.stdout.fnmatch_lines('*1 passed*')
+        if clean_stop:
+            assert stop_cleanly_result == [True]
+        else:
+            assert stop_cleanly_result == []
+
     def test_add_endpoint_to_live_server(self, appdir):
         appdir.create_test_module('''
             import pytest