"""

Test WSGI basics and provide some helper functions for other WSGI tests.

"""

from nova import test

import routes

import webob

from nova import wsgi

class Test(test.NoDBTestCase):

    def test_debug(self):

        class Application(wsgi.Application):

            """Dummy application to test debug."""

            def __call__(self, environ, start_response):

                start_response("", [("X-Test", "checking")])

                return ['Test result']

        application = wsgi.Debug(Application())

        result = webob.Request.blank('/').get_response(application)

        self.assertEqual(result.body, "Test result")

    def test_router(self):

        class Application(wsgi.Application):

            """Test application to call from router."""

            def __call__(self, environ, start_response):

                start_response("", [])

                return ['Router result']

        class Router(wsgi.Router):

            """Test router."""

            def __init__(self):

                mapper = routes.Mapper()

                mapper.connect("/test", controller=Application())

                super(Router, self).__init__(mapper)

        result = webob.Request.blank('/test').get_response(Router())

        self.assertEqual(result.body, "Router result")

        result = webob.Request.blank('/bad').get_response(Router())

        self.assertNotEqual(result.body, "Router result")

class Router(object):

    """WSGI middleware that maps incoming requests to WSGI apps."""

    def __init__(self, mapper):

        """Create a router for the given routes.Mapper.

        Each route in `mapper` must specify a 'controller', which is a

        WSGI app to call.  You'll probably want to specify an 'action' as

        well and have your controller be an object that can route

        the request to the action-specific method.

        Examples:

          mapper = routes.Mapper()

          sc = ServerController()

          # Explicit mapping of one route to a controller+action

          mapper.connect(None, '/svrlist', controller=sc, action='list')

          # Actions are all implicitly defined

          mapper.resource('server', 'servers', controller=sc)

          # Pointing to an arbitrary WSGI app.  You can specify the

          # {path_info:.*} parameter so the target app can be handed just that

          # section of the URL.

          mapper.connect(None, '/v1.0/{path_info:.*}', controller=BlogApp())

        """

        self.map = mapper

        self._router = routes.middleware.RoutesMiddleware(self._dispatch,

                                                          self.map)

    @webob.dec.wsgify(RequestClass=Request)

    def __call__(self, req):

        """Route the incoming request to a controller based on self.map.

        If no match, return a 404.

        """

        return self._router

    @staticmethod

    @webob.dec.wsgify(RequestClass=Request)

    def _dispatch(req):

        """Dispatch the request to the appropriate controller.

        Called by self._router after matching the incoming request to a route

        and putting the information into req.environ.  Either returns 404

        or the routed WSGI app's response.

        """

        match = req.environ['wsgiorg.routing_args'][1]

        if not match:

            return webob.exc.HTTPNotFound()

        app = match['controller']

        return app

Constructor information:

 Definition:routes.middleware.RoutesMiddleware(self, wsgi_app, mapper, use_method_override=True, path_info=True, singleton=True)

 Docstring:

    Create a Route middleware object

    Using the use_method_override keyword will require Paste to be

    installed, and your application should use Paste's WSGIRequest

    object as it will properly handle POST issues with wsgi.input

    should Routes check it.

    If path_info is True, then should a route var contain

    path_info, the SCRIPT_NAME and PATH_INFO will be altered

    accordingly. This should be used with routes like:

    .. code-block:: python

        map.connect('blog/*path_info', controller='blog', path_info='')

class Loader(object):

    """Used to load WSGI applications from paste configurations."""

    def __init__(self, config_path=None):

        """Initialize the loader, and attempt to find the config.

        :param config_path: Full or relative path to the paste config.

        :returns: None

        """

        self.config_path = None

        config_path = config_path or CONF.api_paste_config

        if not os.path.isabs(config_path):

            self.config_path = CONF.find_file(config_path)

        elif os.path.exists(config_path):

            self.config_path = config_path

        if not self.config_path:

            raise exception.ConfigNotFound(path=config_path)

    def load_app(self, name):

        """Return the paste URLMap wrapped WSGI application.

        :param name: Name of the application to load.

        :returns: Paste URLMap object wrapping the requested application.

        :raises: `nova.exception.PasteAppNotFound`

        """

        try:

            LOG.debug("Loading app %(name)s from %(path)s",

                      {'name': name, 'path': self.config_path})

            return deploy.loadapp("config:%s" % self.config_path, name=name)

        except LookupError:

            LOG.exception(_LE("Couldn't lookup app: %s"), name)

            raise exception.PasteAppNotFound(name=name, path=self.config_path)