def setUp(self):
        self.routing_table = TreeRoutingTable()
        self.routing_table.register_route(GET, PATH, RESOURCE_CLASS,
                                          ROUTE_METHOD)
        self.route_handler_factory = RouteHandlerFactory(
            ServiceLocator(), Deserializer(Registry()),
            [RoutingRule("/", self.routing_table)],
            CorsRequestHandlerFactory([CorsRule("/", {})]))

        self.request_builder = RequestBuilder().method("GET").path(PATH)
Exemple #2
0
class RoutingRuleTest(unittest.TestCase):
    def setUp(self):
        self.routing_table = TreeRoutingTable()
        self.routing_table.register_route(GET, "/path", object(), object())

    def test_matchingPrefixRootPrefix(self):
        rule = RoutingRule("/", None)

        self.assertTrue(rule.matches("/foo"))
        self.assertTrue(rule.matches("/"))

    def test_matchingPrefix(self):
        rule = RoutingRule("/users", None)

        self.assertTrue(rule.matches("/users"))
        self.assertTrue(rule.matches("/users/foo/bar/delete"))
        self.assertFalse(rule.matches("/admin"))

    def test_givenPathWhichDoesNotMatchRule_whenGettingRouteRegistrations_thenReturnEmptyList(
            self):
        rule = RoutingRule("/users", None)

        routes = rule.get_route_registrations("/foobar")

        self.assertEqual(0, len(routes))

    def test_whenCreatingRouteHandlers_thenRewritePaths(self):
        request = RequestBuilder().path("/users/path").build()
        rule = RoutingRule("/users", self.routing_table, rewrite_path=True)

        handlers = [x for x in rule.create_route_handlers(request, None, None)]

        self.assertIsInstance(handlers[0], PathRewritingRouteHandlerDecorator)

    def test_givenShouldNotRewritePath_whenCreatingRouteHandlers_thenReturnStandardResourceInvokers(
            self):
        request = RequestBuilder().path("/users/path").build()
        rule = RoutingRule("/users", self.routing_table, rewrite_path=False)

        handlers = [x for x in rule.create_route_handlers(request, None, None)]

        self.assertIsInstance(handlers[0], ResourceInvoker)
Exemple #3
0
from jivago.wsgi.methods import GET
from jivago.wsgi.routing.routing_rule import RoutingRule
from jivago.wsgi.routing.serving.static_file_routing_table import StaticFileRoutingTable
from jivago.wsgi.routing.table.tree_routing_table import TreeRoutingTable

my_routing_table = TreeRoutingTable()
my_routing_table.register_route(GET, "/hello", HelloClass,
                                HelloClass.get_hello)

root_rule = RoutingRule("/", my_routing_table)
my_rule = RoutingRule("/static",
                      StaticFileRoutingTable("/var/www"),
                      rewrite_path=True)
Exemple #4
0
from jivago.wsgi.methods import GET, POST
from jivago.wsgi.routing.table.tree_routing_table import TreeRoutingTable

my_routing_table = TreeRoutingTable()

my_routing_table.register_route(GET, "/hello", MyResourceClass,
                                MyResourceClass.get_hello)
my_routing_table.register_route(POST, "/hello", MyResourceClass,
                                MyResourceClass.get_hello)
class RouteHandlerFactoryTest(unittest.TestCase):
    def setUp(self):
        self.routing_table = TreeRoutingTable()
        self.routing_table.register_route(GET, PATH, RESOURCE_CLASS,
                                          ROUTE_METHOD)
        self.route_handler_factory = RouteHandlerFactory(
            ServiceLocator(), Deserializer(Registry()),
            [RoutingRule("/", self.routing_table)],
            CorsRequestHandlerFactory([CorsRule("/", {})]))

        self.request_builder = RequestBuilder().method("GET").path(PATH)

    def test_givenNoMatchingRoutes_whenCreatingRouteHandlers_thenRaiseUnknownPathException(
            self):
        request = self.request_builder.path("/unknown").build()

        with self.assertRaises(UnknownPathException):
            self.route_handler_factory.create_route_handlers(request)

    def test_givenDisallowedMethod_whenCreatingRouteHandlers_thenRaiseMethodNotAllowedException(
            self):
        request = self.request_builder.method("POST").build()

        with self.assertRaises(MethodNotAllowedException):
            self.route_handler_factory.create_route_handlers(request)

    def test_givenPrefixedRule_whenCreatingRouteHandlers_thenCreateResourceInvokerWithTruncatedPathForEveryRoute(
            self):
        request = self.request_builder.path("/prefix" + PATH).build()
        rule = RoutingRule("/prefix", self.routing_table)
        self.route_handler_factory = RouteHandlerFactory(
            ServiceLocator(), Deserializer(Registry()), [rule],
            CorsRequestHandlerFactory([CorsRule("/", {})]))

        handlers: List[PathRewritingRouteHandlerDecorator] = [
            x
            for x in self.route_handler_factory.create_route_handlers(request)
        ]

        self.assertEqual(1, len(handlers))
        # TODO do assertion which does not imply internal structure
        self.assertEqual(PATH, handlers[0].route_handler.new_path)

    def test_givenCorsRequestOnUnknownPath_whenCreatingRouteHandlers_thenRaiseUnknownPathException(
            self):
        request = self.request_builder.method("OPTIONS").path(
            "/unknown").build()

        with self.assertRaises(UnknownPathException):
            self.route_handler_factory.create_route_handlers(request)

    def test_givenCorsRequest_whenCreatingRouteHandlers_thenReturnSingleCorsHandler(
            self):
        request = self.request_builder.method("OPTIONS").build()

        handlers = [
            x
            for x in self.route_handler_factory.create_route_handlers(request)
        ]

        self.assertEqual(1, len(handlers))
        self.assertIsInstance(handlers[0], CorsPreflightRequestHandler)
Exemple #6
0
 def setUp(self):
     self.routing_table = TreeRoutingTable()
     self.routing_table.register_route(GET, "/path", object(), object())