Add live server test to suite.

Now the testsuite starts an instance of the roundup tracker. It then
uses requests to verify the main page is acessible.

At some point this will be extended to use selemium or splinter to
drive more extensive end to end testing.

Author: rouilj

.travis.yml

@@ -92,7 +92,7 @@ install:
   - if [[ $TRAVIS_PYTHON_VERSION == "3.4"* ]]; then  pip install mysqlclient==1.3.14; fi
   - if [[ $TRAVIS_PYTHON_VERSION != "3.4"* ]]; then pip install mysqlclient; fi
   - pip install psycopg2
-  - pip install gpg pytz whoosh pyjwt
+  - pip install gpg pytz whoosh pyjwt requests
   - pip install pytest-cov codecov
   - if [[ $TRAVIS_PYTHON_VERSION != "3.4"* ]]; then pip install docutils; fi
   - if [[ $TRAVIS_PYTHON_VERSION != "3.4"* ]]; then pip install mistune; fi

CHANGES.txt

@@ -126,6 +126,9 @@ Features:
   memorydb convenience functions and it may be useful in other tests. Make
   the prefix a paramter of the convenience functions to be usable in other
   tests.
+- pytest suite now starts the server under wsgi and loads the home
+  page. This test is skipped if the requests module is not installed.
+ 
 
 2020-07-13 2.0.0
 

test/test_liveserver.py

@@ -0,0 +1,60 @@
+import shutil, errno, pytest
+
+from roundup.cgi.wsgi_handler import RequestDispatcher
+from .wsgi_liveserver import LiveServerTestCase
+from . import db_test_base
+
+try:
+    import requests
+    skip_requests = lambda func, *args, **kwargs: func
+except ImportError:
+    from .pytest_patcher import mark_class
+    skip_requests = mark_class(pytest.mark.skip(
+        reason='Skipping liveserver tests: requests library not available'))
+    
+@skip_requests
+class SimpleTest(LiveServerTestCase):
+    port_range = (9001, 9010)  # default is (8080, 8090)
+
+    dirname = '_test_instance'
+    backend = 'anydbm'
+    
+    @classmethod
+    def setup_class(cls):
+        '''All test in this class use the same roundup instance.
+           This instance persists across all tests.
+           Create the tracker dir here so that it is ready for the
+           create_app() method to be called.
+        '''
+        # tests in this class.
+        # set up and open a tracker
+        cls.instance = db_test_base.setupTracker(cls.dirname, cls.backend)
+
+        # open the database
+        cls.db = cls.instance.open('admin')
+
+        cls.db.commit()
+        cls.db.close()
+
+    @classmethod
+    def teardown_class(cls):
+        '''Close the database and delete the tracker directory
+           now that the app should be exiting.
+        '''
+        if cls.db:
+            cls.db.close()
+        try:
+            shutil.rmtree(cls.dirname)
+        except OSError as error:
+            if error.errno not in (errno.ENOENT, errno.ESRCH): raise
+
+    def create_app(self):
+        '''The wsgi app to start'''
+        return RequestDispatcher(self.dirname)
+
+    def test_start_page(self):
+        """ simple test that verifies that the server can serve a start page.
+        """
+        f = requests.get(self.url_base())
+        self.assertTrue(b'Roundup' in f.content)
+        self.assertTrue(b'Creator' in f.content)

test/wsgi_liveserver.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""
+wsgi-liveserver provides a simple LiverServerTestCase class that can be used to
+help start a web server in the background to serve a WSGI compliant application
+for use with testing. Generally it will be used in conjuction with something
+like Selenium to perform a series of functional tests using a browser.
+
+Licensed under the GNU GPL v3
+
+Copyright (c) 2013 John Kristensen (unless explicitly stated otherwise).
+"""
+import threading
+import socket
+import unittest
+from wsgiref.simple_server import make_server, WSGIRequestHandler
+
+__author__ = 'John Kristensen'
+__version__ = '0.3.1'
+__license__ = 'GPLv3'
+
+
+class QuietHandler(WSGIRequestHandler):
+    def log_request(*args, **kwargs):
+        pass
+
+
+class LiveServerTestCase(unittest.TestCase):
+
+    port_range = (8080, 8090)
+
+    def create_app(self):
+        """Create your wsgi app and return it."""
+        raise NotImplementedError
+
+    def __call__(self, result=None):
+        """
+        Do some custom setup stuff and then hand off to TestCase to do its
+        thing.
+        """
+        try:
+            self._pre_setup()
+            super(LiveServerTestCase, self).__call__(result)
+        finally:
+            self._post_teardown()
+
+    def url_base(self):
+        """Return the url of the test server."""
+        return 'http://{0}:{1}'.format(self.host, self.port)
+
+    def _pre_setup(self):
+        """Setup and start the test server in the background."""
+        self._server = None
+
+        self.host = 'localhost'
+        self.port = self.port_range[0]
+        self._thread = None
+
+        # Get the app
+        self.app = self.create_app()
+
+        # Cycle through the port range to find a free port
+        while self._server is None and self.port <= self.port_range[1]:
+            try:
+                self._server = make_server(self.host, self.port, self.app,
+                                           handler_class=QuietHandler)
+            except socket.error:
+                self.port += 1
+
+        # No free port, raise an exception
+        if self._server is None:
+            raise socket.error('Ports {0}-{1} are all already in use'.format(
+                *self.port_range))
+
+        # Start the test server in the background
+        self._thread = threading.Thread(target=self._server.serve_forever)
+        self._thread.start()
+
+    def _post_teardown(self):
+        """Stop the test server."""
+        if self._thread is not None:
+            self._server.shutdown()
+            self._server.server_close()
+            self._thread.join()
+            del self._server