Gettings settings and config from INI file for Pyramid functional testing

Question

In a real Pyramid app it does not work per docs http://docs.pylonsproject.org/projects/pyramid//en/latest/narr/testing.html :

class FunctionalTests(unittest.TestCase):
    def setUp(self):
        from myapp import main
        app = main({})

Exception:

Traceback (most recent call last):
  File "C:\projects\myapp\tests\model\task_dispatcher_integration_test.py", line 35, in setUp
    app = main({})
  File "C:\projects\myapp\myapp\__init__.py", line 207, in main
    engine = engine_from_config(settings, 'sqlalchemy.')
  File "C:\projects\myapp\ve\lib\site-packages\sqlalchemy\engine\__init__.py", line 407, in engine_from_config
    url = options.pop('url')
KeyError: 'url'

The reason is trivial: an empty dictionary is passed to main, while it seems that while running real app (from __init__.py) it gets settings pre-filled with values from [app:main] section of development.ini / production.ini:

settings {'ldap_port': '4032', 'sqlalchemy.url': 'postgresql://.....}

Is there some way of reconstructing settings easily from an .ini file for functional testing?

Answer 1

Actually, you don't need import get_appsettings, just add the parameters like this:

class FunctionalTests(unittest.TestCase):
def setUp(self):
    from myapp import main
    settings = {'sqlalchemy.url': 'sqlite://'}
    app = main({}, **settings)

here is the source: functional test, it is in the second block code, line 31.

Answer 2

pyramid.paster.get_appsettings is the only thing you need:

from pyramid.paster import get_appsettings

settings = get_appsettings('test.ini', name='main')
app = main(settings)

---

That test.ini can include all the settings of another .ini file easily like this:

[app:main]
use = config:development.ini#main

and then you only need to override those keys that change (I guess you'd want to rather test against a separate DB):

[app:main]
use = config:development.ini#main
sqlalchemy.uri = postgresql://....

Answer 3

In case anyone else doesn't get @antti-haapala's answer right away:

Create a test.ini filled with:

[app:main]
use = config:development.ini#main

(Actually this step is not necessary. You could also keep your development.ini and use it instead of test.ini in the following code. A separate test.ini might however be useful if you want separate settings for testing)

In your tests.py add:

from pyramid.paster import get_appsettings
settings = get_appsettings('test.ini', name='main')

and replace

app = TestApp(main({}))

with

app = TestApp(main(global_config = None, **settings))

Relevant for this answer was the following comment: Pyramid fails to start when webtest and sqlalchemy are used together

Answer 4

Yes there is, though the easy is a subject to debate.

I am using the following py.test test fixture to make --ini option passed to the tests. However this approach is limited to py.test test runner, as other test runner do not have such flexibility.

Also my test.ini has special settings like disabling outgoing mail and instead printing it out to terminal and test accessible backlog.

@pytest.fixture(scope='session')
def ini_settings(request):
    """Load INI settings for test run from py.test command line.

    Example:

         py.test yourpackage -s --ini=test.ini


    :return: Adictionary representing the key/value pairs in an ``app`` section within the file represented by ``config_uri``
    """

    if not getattr(request.config.option, "ini", None):
        raise RuntimeError("You need to give --ini test.ini command line option to py.test to find our test settings")

    # Unrelated, but if you need to poke standard Python ConfigParser do it here
    # from websauna.utils.configincluder import monkey_patch_paster_config_parser
    # monkey_patch_paster_config_parser()

    config_uri = os.path.abspath(request.config.option.ini)
    setup_logging(config_uri)
    config = get_appsettings(config_uri)

    # To pass the config filename itself forward 
    config["_ini_file"] = config_uri

    return config

Then I can set up app (note that here pyramid.paster.bootstrap parses the config file again:

@pytest.fixture(scope='session')
def app(request, ini_settings, **settings_overrides):
    """Initialize WSGI application from INI file given on the command line.

    TODO: This can be run only once per testing session, as SQLAlchemy does some stupid shit on import, leaks globals and if you run it again it doesn't work. E.g. trying to manually call ``app()`` twice::

         Class <class 'websauna.referral.models.ReferralProgram'> already has been instrumented declaratively

    :param settings_overrides: Override specific settings for the test case.

    :return: WSGI application instance as created by ``Initializer.make_wsgi_app()``.
    """
    if not getattr(request.config.option, "ini", None):
        raise RuntimeError("You need to give --ini test.ini command line option to py.test to find our test settings")

    data = bootstrap(ini_settings["_ini_file"])
    return data["app"]

Furthermore setting up a functional test server:

import threading
import time
from wsgiref.simple_server import make_server
from urllib.parse import urlparse
from pyramid.paster import bootstrap

import pytest
from webtest import TestApp

from backports import typing

#: The URL where WSGI server is run from where Selenium browser loads the pages
HOST_BASE = "http://localhost:8521"


class ServerThread(threading.Thread):
    """ Run WSGI server on a background thread.

    Pass in WSGI app object and serve pages from it for Selenium browser.
    """

    def __init__(self, app, hostbase=HOST_BASE):
        threading.Thread.__init__(self)
        self.app = app
        self.srv = None
        self.daemon = True
        self.hostbase = hostbase

    def run(self):
        """Open WSGI server to listen to HOST_BASE address
        """
        parts = urlparse(self.hostbase)
        domain, port = parts.netloc.split(":")
        self.srv = make_server(domain, int(port), self.app)
        try:
            self.srv.serve_forever()
        except Exception as e:
            # We are a background thread so we have problems to interrupt tests in the case of error
            import traceback
            traceback.print_exc()
            # Failed to start
            self.srv = None

    def quit(self):
        """Stop test webserver."""
        if self.srv:
            self.srv.shutdown()


@pytest.fixture(scope='session')
def web_server(request, app) -> str:
    """py.test fixture to create a WSGI web server for functional tests.

    :param app: py.test fixture for constructing a WSGI application

    :return: localhost URL where the web server is running.
    """

    server = ServerThread(app)
    server.start()

    # Wait randomish time to allows SocketServer to initialize itself.
    # TODO: Replace this with proper event telling the server is up.
    time.sleep(0.1)

    assert server.srv is not None, "Could not start the test web server"

    host_base = HOST_BASE

    def teardown():
        server.quit()

    request.addfinalizer(teardown)
    return host_base