Exemplo n.º 1
0
 def test_success(self):
     response = Response(body="Hi")
     app = App()
     app.expose('/')(lambda request: response)
     resp = app.route({'REQUEST_METHOD': 'GET',
                        'PATH_INFO': '/'})
     self.assertTrue(resp is response)
Exemplo n.º 2
0
class RenderTest(unittest.TestCase):

    def setUp(self):
        self.app = App()

    def test_httpexception(self):
        ex = exc.HTTPNotFound(detail="test")
        out = self.app._render({}, (Request(_env()), ex))
        self.assertTrue(out[0].startswith('404'))

    def test_non_httpexception(self):
        ex = ValueError("WTF")
        out = self.app._render({}, (Request(_env()), ex))
        self.assertTrue(out[0].startswith("500"))

    def test_json_type(self):
        ex = ValueError("WTF")
        out = self.app._render({}, (Request(_env()), ex))
        headers = dict(out[1])
        self.assertTrue('Content-Type' in headers)
        self.assertEqual(headers['Content-Type'], 'application/json')

    def test_bad_response(self):
        resp = self.app._render({}, (Request(_env()), "foo"))
        self.assertTrue(isinstance(resp, tuple))
        self.assertTrue(resp[0].startswith("500"))

    def test_bad_request(self):
        message = "You dun goof'd"
        ex = exc.HTTPBadRequest(message)
        (response, headers, body) = self.app._render({}, (Request(_env()), ex))
        body = "".join(body)
        self.assertTrue(len(body) > 0)
        blab = json.loads(body)
        self.assertEqual(blab['detail'], message)
Exemplo n.º 3
0
class RenderTest(unittest.TestCase):

    def setUp(self):
        self.app = App()

    def test_httpexception(self):
        ex = exc.HTTPNotFound(detail="test")
        out = self.app._render({}, ex)
        print out
        self.assertTrue(out[0].startswith('404'))

    def test_non_httpexception(self):
        ex = ValueError("WTF")
        out = self.app._render({}, ex)
        self.assertTrue(out[0].startswith("500"))

    def test_json_type(self):
        ex = ValueError("WTF")
        out = self.app._render({}, ex)
        headers = dict(out[1])
        self.assertTrue('Content-Type' in headers)
        self.assertEqual(headers['Content-Type'], 'application/json')

    def test_bad_response(self):
        resp = self.app._render({}, "foo")
        self.assertTrue(isinstance(resp, tuple))
        self.assertTrue(resp[0].startswith("500"))
Exemplo n.º 4
0
 def test_has_prefix(self):
     """Make sure endpoint URLs include the prefix."""
     prefix = "/foo"
     app = App(prefix=prefix)
     endpoints(app, "/endpoints")
     for endpoint in app.endpoints().iterkeys():
         self.assertTrue(prefix in endpoint)
Exemplo n.º 5
0
class TestExpose(unittest.TestCase):

    """Test App.expose."""

    def setUp(self):
        self.app = App()

    def test_expose_method(self):
        """Make sure the original method is preserved."""
        f = lambda request: None
        f_ = self.app.expose('/test_expose')(f)
        self.assert_(f_ is f)

    def test_expose_methods(self):
        """Make sure invalid methods raise an exception."""
        self.assertRaises(Exception, self.app.expose, '/foo', 'CHEESE')

    def test_expose_method_maps(self):
        """Make sure patterns are added to the correct maps."""
        url, method = ('/cheese', 'GET')
        old_len = len(self.app.map[method]._patterns)
        f = lambda request: None
        self.app.expose(url, method)(f)
        self.assert_(len(self.app.map[method]._patterns) > old_len)
        self.assert_(url in self.app.map[method]._patterns)
        self.assert_(self.app.map[method]._patterns[url][1] is f)

    def test_expose_method_decorates(self):
        """Make sure functions aren't decorated when added."""
        url, method = ('/shop', 'GET')
        old_len = len(self.app.map[method]._patterns)
        f = lambda request: None
        self.app.expose(url, method)(f)
        self.assert_(self.app.map[method]._patterns[url][1] is f)
Exemplo n.º 6
0
    def test_endpoints(self):
        """Make sure hidden functions don't show up in endpoints."""
        app = App()

        @app.expose('/endpoint')
        @hidden
        def endpoint(request):
            return Response()

        self.assertFalse(app.endpoints())
Exemplo n.º 7
0
    def test_unicode_request(self):
        """Make sure the request uses Unicode."""
        env = {'QUERY_STRING': 'q=ü'}
        app = App()

        @app.expose("/foo")
        def __endpoint__(request):
            self.assertTrue(isinstance(request.GET, webob.UnicodeMultiDict))

        app.route({'REQUEST_METHOD': 'GET',
                   'PATH_INFO': "/foo"})
Exemplo n.º 8
0
    def test_exceptions_returned(self):
        """Make sure non-HTTPExceptions are returned."""
        ex = Exception("Test exception")
        app = App()

        @app.expose("/foo")
        def test_f(request):
            raise ex

        (req, resp) = app.route({'REQUEST_METHOD': 'GET',
                            'PATH_INFO': "/foo"})
        self.assert_(resp is ex)
Exemplo n.º 9
0
    def test_generates_request(self):
        """Make sure request objects are generated."""
        runs = []
        app = App()

        @app.expose("/foo")
        def test_f(request):
            runs.append(True)
            self.assert_(isinstance(request, Request))
            return Response()

        (req, resp) = app.route({'REQUEST_METHOD': 'GET', 'PATH_INFO': "/foo"})
        self.assert_(len(runs) == 1)
Exemplo n.º 10
0
    def test_multi_expose(self):
        app = App()

        @app.expose("/foo")
        @app.expose("/bar")
        def endpoint(request):
            return Response(body="Hi.")

        (req, resp) = app.route({'REQUEST_METHOD': "GET",
                                 'PATH_INFO': "/foo"})
        self.assertTrue(isinstance(resp, Response))
        self.assertFalse(isinstance(resp, exc.HTTPError))
        self.assertTrue(resp.body == "Hi.")
Exemplo n.º 11
0
class GetEndpointsTest(unittest.TestCase):

    """Test _get_endpoints."""

    def setUp(self):
        self.app = App()

    def test_endpoints(self):
        self.app.expose('foo')(lambda request: Response())
        self.app.expose('bar')(lambda request: Response())

        endpoints = self.app.endpoints()
        self.assertTrue('GET foo' in endpoints.keys())
        self.assertTrue('GET bar' in endpoints.keys())
Exemplo n.º 12
0
class EndpointsTest(unittest.TestCase):

    """Test dream.endpoints()"""

    def setUp(self):
        self.app = App()
        endpoints(self.app, '/endpoints')

    def test_endpoints(self):
        self.assertTrue('GET /endpoints' in self.app.endpoints().keys())

    def test_endpoints_reponse(self):
        self.assertTrue(isinstance(
                self.app.route({'REQUEST_METHOD': 'GET',
                                'PATH_INFO': '/endpoints'}),
                HumanReadableJSONResponse))
Exemplo n.º 13
0
class MangleResponseTest(unittest.TestCase):

    """Make sure _mangle_response works."""

    def setUp(self):
        self.app = App(debug=True)

    def test_exceptions(self):
        """Make sure exceptions are handled properly."""
        exc = ValueError("Expected some cheese.")
        resp = self.app._mangle_response(Request(_env()), exc)
        body = json.loads(resp.body)
        self.assertTrue(body['detail'].startswith('Caught exception ' +
                                                  str(type(exc))))

    def test_traceback_list(self):
        """Make sure tracebacks are included when they're lists."""
        ex = Exception("foo")
        ex.__traceback__ = traceback.extract_stack()

        resp = _debug_exception_to_reponse(Request(_env()), ex)
        body = json.loads(resp.body)
        self.assertTrue('traceback' in body)
        self.assertNotEqual(body['traceback'], ["No traceback available."])

    def test_nonerror_exceptions(self):
        """Non-error exceptions shouldn't get mangled a traceback."""
        ex = exc.HTTPMovedPermanently(headers={'Location': "/foo.json"})
        resp = self.app._mangle_response(Request(_env()), ex)
        self.assertTrue(resp is ex)

    def test_server_error_exceptions(self):
        """Non-error exceptions shouldn't get mangled a traceback."""
        ex = exc.HTTPInternalServerError()
        resp = self.app._mangle_response(Request(_env()), ex)
        self.assertTrue(resp is not ex)

    def test_client_error_exceptions(self):
        """Non-error exceptions shouldn't get mangled a traceback."""
        ex = exc.HTTPBadRequest()
        resp = self.app._mangle_response(Request(_env()), ex)
        self.assertTrue(resp is not ex)
Exemplo n.º 14
0
class EndpointsTest(unittest.TestCase):

    """Test dream.endpoints()"""

    def setUp(self):
        self.app = App()
        endpoints(self.app, '/endpoints')

    def test_endpoints(self):
        self.assertTrue('GET /endpoints' in self.app.endpoints().keys())

    def test_endpoints_reponse(self):
        (request, response) = self.app.route({'REQUEST_METHOD': 'GET',
                                              'PATH_INFO': '/endpoints'})
        self.assertTrue(isinstance(response, HumanReadableJSONResponse))

    def test_has_prefix(self):
        """Make sure endpoint URLs include the prefix."""
        prefix = "/foo"
        app = App(prefix=prefix)
        endpoints(app, "/endpoints")
        for endpoint in app.endpoints().iterkeys():
            self.assertTrue(prefix in endpoint)
Exemplo n.º 15
0
class MangleResponseTest(unittest.TestCase):

    """Make sure _mangle_response works."""

    def setUp(self):
        self.app = App(debug=True)

    def test_exceptions(self):
        """Make sure exceptions are handled properly."""
        exc = ValueError("Expected some cheese.")
        resp = self.app._mangle_response(exc)
        body = json.loads(resp.body)
        self.assertTrue(body['detail'].startswith('Caught exception ' +
                                                  str(type(exc))))
Exemplo n.º 16
0
 def test_debug_exceptions(self):
     """Make sure exceptions are handled properly based on debug."""
     app = App(debug=True)
     resp = app._mangle_response(exc.HTTPBadRequest("Whops"))
     self.assertTrue('traceback' in json.loads(resp.body))
Exemplo n.º 17
0
 def setUp(self):
     self.app = App()
Exemplo n.º 18
0
 def setUp(self):
     self.app = App(debug=True)
Exemplo n.º 19
0
 def test_nondebug_exceptions(self):
     """Make sure exceptions are handled properly based on debug."""
     app = App(debug=False)
     resp = app._mangle_response(
         Request(_env()), exc.HTTPInternalServerError("Whops"))
     self.assertFalse('traceback' in json.loads(resp.body))
Exemplo n.º 20
0
 def setUp(self):
     self.app = App()
     endpoints(self.app, '/endpoints')
Exemplo n.º 21
0
 def test_nonprefix_404(self):
     app = App()
     (req, resp) = app.route({'REQUEST_METHOD': 'GET', 'PATH_INFO': '/foo'})
     self.assertTrue(isinstance(resp, exc.HTTPNotFound))
Exemplo n.º 22
0
 def test_prefix_404(self):
     app = App(prefix='/1.0')
     self.assertTrue(isinstance(
             app.route({'REQUEST_METHOD': 'GET', 'PATH_INFO': '/foo'})[1],
             exc.HTTPNotFound))