def test_one_field(self):
        fields, pattern = routing.compile_uri_template('/{name}')
        assert fields == set(['name'])

        result = pattern.match('/Kelsier')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}

        fields, pattern = routing.compile_uri_template('/character/{name}')
        assert fields == set(['name'])

        result = pattern.match('/character/Kelsier')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}

        fields, pattern = routing.compile_uri_template(
            '/character/{name}/profile')
        assert fields == set(['name'])

        assert not pattern.match('/character')
        assert not pattern.match('/character/Kelsier')
        assert not pattern.match('/character/Kelsier/')

        result = pattern.match('/character/Kelsier/profile')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}
    def test_one_field(self):
        fields, pattern = routing.compile_uri_template('/{name}')
        assert fields == set(['name'])

        result = pattern.match('/Kelsier')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}

        fields, pattern = routing.compile_uri_template('/character/{name}')
        assert fields == set(['name'])

        result = pattern.match('/character/Kelsier')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}

        fields, pattern = routing.compile_uri_template('/character/{name}/profile')
        assert fields == set(['name'])

        assert not pattern.match('/character')
        assert not pattern.match('/character/Kelsier')
        assert not pattern.match('/character/Kelsier/')

        result = pattern.match('/character/Kelsier/profile')
        assert result
        assert result.groupdict() == {'name': 'Kelsier'}
Beispiel #3
0
    def test_one_field(self):
        fields, pattern = routing.compile_uri_template('/{name}')
        self.assertEqual(fields, set(['name']))

        result = pattern.match('/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})

        fields, pattern = routing.compile_uri_template('/character/{name}')
        self.assertEqual(fields, set(['name']))

        result = pattern.match('/character/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})

        fields, pattern = routing.compile_uri_template(
            '/character/{name}/profile')
        self.assertEqual(fields, set(['name']))

        self.assertFalse(pattern.match('/character'))
        self.assertFalse(pattern.match('/character/Kelsier'))
        self.assertFalse(pattern.match('/character/Kelsier/'))

        result = pattern.match('/character/Kelsier/profile')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})
    def test_one_field(self):
        fields, pattern = routing.compile_uri_template('/{name}')
        self.assertEqual(fields, set(['name']))

        result = pattern.match('/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})

        fields, pattern = routing.compile_uri_template('/character/{name}')
        self.assertEqual(fields, set(['name']))

        result = pattern.match('/character/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})

        fields, pattern = routing.compile_uri_template('/character/{name}/profile')
        self.assertEqual(fields, set(['name']))

        self.assertFalse(pattern.match('/character'))
        self.assertFalse(pattern.match('/character/Kelsier'))
        self.assertFalse(pattern.match('/character/Kelsier/'))

        result = pattern.match('/character/Kelsier/profile')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Kelsier'})
    def load_spec_swagger(self, swagger_spec):
        # a Swagger spec (typically filenamed api-docs.json) defines a number of API "operations"
        # each operationId is (meant to be) unique and defines the operation's HTTP method & a URI template
        #
        # the routing table here is a dict that allows lookup of a Swagger operationId and its URI template
        # when an HTTP request comes in, we work out which Swagger operationId it maps to
        # this is done by doing a regular expression match of the inbound URL to each URI template until we
        # find the correct Swagger operationId

        # you can add multiple Swagger specs but be aware that a duplicate operationId will overwrite existing


        # this function sets up the routing table by parsing the Swagger spec JSON
        log.info("Loading swagger spec into routing table")
        # param swagger_spec is a JSON document
        try:
            swagger_spec = json.loads(swagger_spec)
        except:
            raise Exception("Unable to parse the Swagger spec JSON document.")
        try:
            for k in swagger_spec['paths'].keys():
                for http_method in swagger_spec['paths'][k].keys():
                    uri_fields, uri_template = compile_uri_template('/' + http_method.lower() + '/3.0' + k)
                    self.routing_templates.append(repr(uri_template))
                    operationId = swagger_spec['paths'][k][http_method]['operationId']
                    self.routing_table[operationId] = {'uri_fields': uri_fields, 'uri_template': uri_template}
                    if operationId not in self.operation_handlers.keys():
                        log.warning('In Swagger spec but not in operation_handlers: {}'.format(operationId))
        except:
            raise Exception("Unable to build routing table from provided Swagger spec.")
    def test_three_fields(self):
        fields, pattern = routing.compile_uri_template('/{a}/{b}/x/{c}')
        assert fields == set('abc')

        result = pattern.match('/one/2/x/3')
        assert result
        assert result.groupdict() == {'a': 'one', 'b': '2', 'c': '3'}
Beispiel #7
0
    def test_malformed_field(self):
        fields, pattern = routing.compile_uri_template('/{a}/{1b}/x/{c}')
        self.assertEqual(fields, set('ac'))

        result = pattern.match('/one/{1b}/x/3')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'a': 'one', 'c': '3'})
    def test_malformed_field(self):
        fields, pattern = routing.compile_uri_template('/{a}/{1b}/x/{c}')
        assert fields == set('ac')

        result = pattern.match('/one/{1b}/x/3')
        assert result
        assert result.groupdict() == {'a': 'one', 'c': '3'}
    def test_one_field_with_digits(self):
        fields, pattern = routing.compile_uri_template('/{name123}')
        self.assertEqual(fields, set(['name123']))

        result = pattern.match('/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name123': 'Kelsier'})
    def test_one_field_with_digits(self):
        fields, pattern = routing.compile_uri_template('/{name123}')
        assert fields == set(['name123'])

        result = pattern.match('/Kelsier')
        assert result
        assert result.groupdict() == {'name123': 'Kelsier'}
    def test_one_field_with_digits(self):
        fields, pattern = routing.compile_uri_template('/{name123}')
        assert fields == set(['name123'])

        result = pattern.match('/Kelsier')
        assert result
        assert result.groupdict() == {'name123': 'Kelsier'}
Beispiel #12
0
    def test_one_field_with_digits(self):
        fields, pattern = routing.compile_uri_template('/{name123}')
        self.assertEqual(fields, set(['name123']))

        result = pattern.match('/Kelsier')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name123': 'Kelsier'})
    def test_three_fields(self):
        fields, pattern = routing.compile_uri_template('/{a}/{b}/x/{c}')
        assert fields == set('abc')

        result = pattern.match('/one/2/x/3')
        assert result
        assert result.groupdict() == {'a': 'one', 'b': '2', 'c': '3'}
    def test_malformed_field(self):
        fields, pattern = routing.compile_uri_template('/{a}/{1b}/x/{c}')
        assert fields == set('ac')

        result = pattern.match('/one/{1b}/x/3')
        assert result
        assert result.groupdict() == {'a': 'one', 'c': '3'}
Beispiel #15
0
    def test_three_fields(self):
        fields, pattern = routing.compile_uri_template('/{a}/{b}/x/{c}')
        self.assertEqual(fields, set('abc'))

        result = pattern.match('/one/2/x/3')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'a': 'one', 'b': '2', 'c': '3'})
    def test_malformed_field(self):
        fields, pattern = routing.compile_uri_template('/{a}/{1b}/x/{c}')
        self.assertEqual(fields, set('ac'))

        result = pattern.match('/one/{1b}/x/3')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'a': 'one', 'c': '3'})
    def test_three_fields(self):
        fields, pattern = routing.compile_uri_template('/{a}/{b}/x/{c}')
        self.assertEqual(fields, set('abc'))

        result = pattern.match('/one/2/x/3')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'a': 'one', 'b': '2', 'c': '3'})
    def test_no_fields(self, path):
        fields, pattern = routing.compile_uri_template(path)
        assert not fields
        assert not pattern.match(path[:-1])

        result = pattern.match(path)
        assert result
        assert not result.groupdict()
    def test_root(self):
        fields, pattern = routing.compile_uri_template('/')
        assert not fields
        assert not pattern.match('/x')

        result = pattern.match('/')
        assert result
        assert not result.groupdict()
    def test_no_fields(self, path):
        fields, pattern = routing.compile_uri_template(path)
        self.assertFalse(fields)
        self.assertFalse(pattern.match(path[:-1]))

        result = pattern.match(path)
        self.assertTrue(result)
        self.assertFalse(result.groupdict())
    def test_two_fields(self, postfix):
        path = '/book/{id}/characters/{name}' + postfix
        fields, pattern = routing.compile_uri_template(path)
        self.assertEqual(fields, set(['name', 'id']))

        result = pattern.match('/book/0765350386/characters/Vin')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'name': 'Vin', 'id': '0765350386'})
Beispiel #22
0
    def test_no_fields(self, path):
        fields, pattern = routing.compile_uri_template(path)
        self.assertFalse(fields)
        self.assertFalse(pattern.match(path[:-1]))

        result = pattern.match(path)
        self.assertTrue(result)
        self.assertFalse(result.groupdict())
    def test_root(self):
        fields, pattern = routing.compile_uri_template('/')
        assert not fields
        assert not pattern.match('/x')

        result = pattern.match('/')
        assert result
        assert not result.groupdict()
    def test_root(self):
        fields, pattern = routing.compile_uri_template('/')
        self.assertFalse(fields)
        self.assertFalse(pattern.match('/x'))

        result = pattern.match('/')
        self.assertTrue(result)
        self.assertFalse(result.groupdict())
    def test_two_fields(self, postfix):
        path = '/book/{book_id}/characters/{n4m3}' + postfix
        fields, pattern = routing.compile_uri_template(path)
        assert fields == set(['n4m3', 'book_id'])

        result = pattern.match('/book/0765350386/characters/Vin')
        assert result
        assert result.groupdict() == {'n4m3': 'Vin', 'book_id': '0765350386'}
    def test_two_fields(self, postfix):
        path = '/book/{book_id}/characters/{n4m3}' + postfix
        fields, pattern = routing.compile_uri_template(path)
        assert fields == set(['n4m3', 'book_id'])

        result = pattern.match('/book/0765350386/characters/Vin')
        assert result
        assert result.groupdict() == {'n4m3': 'Vin', 'book_id': '0765350386'}
Beispiel #27
0
    def test_two_fields(self, postfix):
        path = '/book/{book_id}/characters/{n4m3}' + postfix
        fields, pattern = routing.compile_uri_template(path)
        self.assertEqual(fields, set(['n4m3', 'book_id']))

        result = pattern.match('/book/0765350386/characters/Vin')
        self.assertTrue(result)
        self.assertEqual(result.groupdict(), {'n4m3': 'Vin', 'book_id': '0765350386'})
    def test_no_fields(self, path):
        fields, pattern = routing.compile_uri_template(path)
        assert not fields
        assert not pattern.match(path[:-1])

        result = pattern.match(path)
        assert result
        assert not result.groupdict()
Beispiel #29
0
    def test_root(self):
        fields, pattern = routing.compile_uri_template('/')
        self.assertFalse(fields)
        self.assertFalse(pattern.match('/x'))

        result = pattern.match('/')
        self.assertTrue(result)
        self.assertFalse(result.groupdict())
Beispiel #30
0
 def load_methods(self, method, method_content, path, swagger_spec):
     uri_fields, uri_regex = compile_uri_template(
         '/' + method.lower() + swagger_spec['basePath'] + path)
     self.specs[uri_regex] = {'uri_fields': uri_fields}
     for attribute, attribute_content in method_content.items():
         if attribute in ['beforeId', 'afterId', 'operationId', 'validationId', 'exceptionId', 'finalId']:
             attribute_content = self.load_handler(attribute_content)
         self.load_attributes(attribute, attribute_content, swagger_spec, uri_regex)
         self.specs[uri_regex]['path'] = path
Beispiel #31
0
    def add_route(self, uri_template, resource):
        """Associates a templatized URI path with a resource.

        A resource is an instance of a class that defines various on_*
        "responder" methods, one for each HTTP method the resource
        allows. For example, to support GET, simply define an `on_get`
        responder. If a client requests an unsupported method, Falcon
        will respond with "405 Method not allowed".

        Responders must always define at least two arguments to receive
        request and response objects, respectively. For example::

            def on_post(self, req, resp):
                pass

        In addition, if the route's template contains field
        expressions, any responder that desires to receive requests
        for that route must accept arguments named after the respective
        field names defined in the template. A field expression consists
        of a bracketed field name.

        For example, given the following template::

            /user/{name}

        A PUT request to "/user/kgriffs" would be routed to::

            def on_put(self, req, resp, name):
                pass

        Args:
            uri_template (str): A templatized URI. Care must be
                taken to ensure the template does not mask any sink
                patterns, if any are registered (see also ``add_sink``).
            resource (instance): Object which represents a REST
                resource. Falcon will pass "GET" requests to on_get,
                "PUT" requests to on_put, etc. If any HTTP methods are not
                supported by your resource, simply don't define the
                corresponding request handlers, and Falcon will do the right
                thing.

        """

        uri_fields, path_template = routing.compile_uri_template(uri_template)
        method_map = routing.create_http_method_map(resource, uri_fields,
                                                    self._before, self._after)

        # Insert at the head of the list in case we get duplicate
        # adds (will cause the last one to win).
        self._routes.insert(0, (path_template, method_map, resource))
Beispiel #32
0
    def add_route(self, uri_template, resource):
        """Associates a templatized URI path with a resource.

        A resource is an instance of a class that defines various on_*
        "responder" methods, one for each HTTP method the resource
        allows. For example, to support GET, simply define an `on_get`
        responder. If a client requests an unsupported method, Falcon
        will respond with "405 Method not allowed".

        Responders must always define at least two arguments to receive
        request and response objects, respectively. For example::

            def on_post(self, req, resp):
                pass

        In addition, if the route's template contains field
        expressions, any responder that desires to receive requests
        for that route must accept arguments named after the respective
        field names defined in the template. A field expression consists
        of a bracketed field name.

        For example, given the following template::

            /user/{name}

        A PUT request to "/user/kgriffs" would be routed to::

            def on_put(self, req, resp, name):
                pass

        Args:
            uri_template (str): A templatized URI. Care must be
                taken to ensure the template does not mask any sink
                patterns, if any are registered (see also `add_sink`).
            resource (instance): Object which represents a REST
                resource. Falcon will pass "GET" requests to on_get,
                "PUT" requests to on_put, etc. If any HTTP methods are not
                supported by your resource, simply don't define the
                corresponding request handlers, and Falcon will do the right
                thing.

        """

        uri_fields, path_template = routing.compile_uri_template(uri_template)
        method_map = routing.create_http_method_map(
            resource, uri_fields, self._before, self._after)

        # Insert at the head of the list in case we get duplicate
        # adds (will cause the last one to win).
        self._routes.insert(0, (path_template, method_map, resource))
Beispiel #33
0
    def load_spec_swagger(self, swagger_spec):
        # a Swagger spec (typically filenamed api-docs.json) defines a number of API "operations"
        # each operationId is (meant to be) unique and defines the operation's HTTP method & a URI template
        #
        # the routing table here is a dict that allows lookup of a Swagger operationId and its URI template
        # when an HTTP request comes in, we work out which Swagger operationId it maps to
        # this is done by doing a regular expression match of the inbound URL to each URI template until we
        # find the correct Swagger operationId

        # you can add multiple Swagger specs but be aware that a duplicate operationId will overwrite existing

        # this function sets up the routing table by parsing the Swagger spec JSON
        log.info("Loading swagger spec into routing table")
        # param swagger_spec is a JSON document
        try:
            swagger_spec = json.loads(swagger_spec)
        except:
            raise Exception("Unable to parse the Swagger spec JSON document.")

        try:
            version = swagger_spec['info']['version']
        except KeyError:
            version = '3.0'
            pass

        try:
            basePath = swagger_spec['basePath']
        except KeyError:
            basePath = ''
        for k in swagger_spec['paths'].keys():
            for http_method in swagger_spec['paths'][k].keys():
                if http_method == 'parameters':
                    continue
                uri_fields, uri_template = compile_uri_template(
                    '/' + http_method.lower() + basePath + '/' + version + k)
                self.routing_templates.append(repr(uri_template))
                operationId = swagger_spec['paths'][k][http_method][
                    'operationId']
                self.routing_table[operationId] = {
                    'uri_fields': uri_fields,
                    'uri_template': uri_template
                }
                if operationId not in self.operation_handlers.keys():
                    log.warning(
                        'In Swagger spec but not in operation_handlers: {}'.
                        format(operationId))
Beispiel #34
0
    def test_one_field_with_prefixed_digits(self):
        fields, pattern = routing.compile_uri_template('/{37signals}')
        self.assertEqual(fields, set())

        result = pattern.match('/s2n')
        self.assertFalse(result)
    def test_one_field_with_prefixed_digits(self):
        fields, pattern = routing.compile_uri_template('/{37signals}')
        self.assertEqual(fields, set())

        result = pattern.match('/s2n')
        self.assertFalse(result)
 def test_template_may_not_contain_double_slash(self, value):
     with pytest.raises(ValueError):
         routing.compile_uri_template(value)
 def test_template_must_start_with_slash(self, value):
     with pytest.raises(ValueError):
         routing.compile_uri_template(value)
 def test_string_type_required(self, value):
     with pytest.raises(TypeError):
         routing.compile_uri_template(value)
Beispiel #39
0
from .. import utils
from .config import PREFIX

logging.getLogger("requests").setLevel(logging.WARNING)

# TODO don't block on sending updates
# TODO async subscription validation
# TODO restarting app/server?
# TODO subscription expiration?
# TODO avoid globals (threading)
# TODO list subscription scalability

SUBSCRIPTIONS = {}

PATTERN_MESSAGES = (
    routing.compile_uri_template('/me/mailFolders/{folderid}/messages')[1],
    'Message')
PATTERN_CONTACTS = (
    routing.compile_uri_template('/me/contactFolders/{folderid}/contacts')[1],
    'Contact')
PATTERN_EVENTS = (
    routing.compile_uri_template('/me/calendars/{folderid}/events')[1],
    'Event')

if PROMETHEUS:
    SUBSCR_COUNT = Counter('kopano_mfr_total_subscriptions',
                           'Total number of subscriptions')
    SUBSCR_ACTIVE = Gauge('kopano_mfr_active_subscriptions',
                          'Number of active subscriptions',
                          multiprocess_mode='livesum')
    POST_COUNT = Counter('kopano_mfr_total_webhook_posts',
    def test_one_field_with_prefixed_digits(self):
        fields, pattern = routing.compile_uri_template('/{37signals}')
        assert fields == set()

        result = pattern.match('/s2n')
        assert not result
Beispiel #41
0
    def add_route(self, resource):
        """Associates uri patterns with resource methods.

        A resource is an instance of a class that defines various methods
        to handle http requests.

        Use this class to create applications which serve a standard
        compliant ReSTful API. For example, you may have an API which manage
        monitoring data, there can be multiple implementations of the API
        using different technologies. One can use Mongodb, the other can use
        Cassandra. To make the configuration of the application very easy,
        each implementation provides a class with set of methods decorated
        by class Restify, the application can simply using single entry
        configuration to load different implementations.

        For example::

            class ExampleResource(object):
                @Restify(path='/path1/', method='post')
                def func1(self, req, res):
                    pass

                @Restify(path='/path2/{id}/key/', method='get')
                def func2(self, req, res, id):
                    pass

                def func3(self, req, res, id):
                    pass

        With the above class, the following code will add the class method
        func1, func2 to handle post and get requests respectively, method
        func3 won't be added to the routes.::

            app.add_route(ExampleResource())

        Args:
            resource (instance): Object which represents an HTTP/REST
                "resource". Falcon will pass requests to various decorated
                methods to handle http requests.
        """
        if not resource:
            raise Exception('Not a valid resource')

        path_maps = {}
        for attr in dir(resource):
            method = getattr(resource, attr)
            if callable(method) and hasattr(method, RESOURCE_METHOD_FLAG):
                flag = getattr(method, RESOURCE_METHOD_FLAG)
                map = path_maps.get(flag.path)
                if not map:
                    uri_fields, template = (
                        routing.compile_uri_template(flag.path))
                    map = (template, {})
                    path_maps[flag.path] = map

                new_method = hooks._wrap_with_hooks(
                    self._before, self._after, method, resource)
                map[1][flag.method] = new_method

        for item in path_maps:
            self._routes.insert(0, (path_maps[item][0],
                                    path_maps[item][1],
                                    resource))
 def test_template_may_not_contain_double_slash(self, value):
     with pytest.raises(ValueError):
         routing.compile_uri_template(value)
Beispiel #43
0
 def test_deprecated_warning(self):
     with pytest.warns(
             DeprecatedWarning,
             match='Call to deprecated function compile_uri_template().',
     ):
         routing.compile_uri_template('/')
    def test_one_field_with_prefixed_digits(self):
        fields, pattern = routing.compile_uri_template('/{37signals}')
        assert fields == set()

        result = pattern.match('/s2n')
        assert not result
 def test_template_must_start_with_slash(self, value):
     with pytest.raises(ValueError):
         routing.compile_uri_template(value)
 def test_string_type_required(self, value):
     with pytest.raises(TypeError):
         routing.compile_uri_template(value)