添加单元测试 添加静态目录

gusibi · gusibi · commit 327cc21fe761 · 2017-07-11T13:20:40.000+08:00
diff --git a/api.yml b/api.yml
@@ -70,6 +70,8 @@ definitions:
         type: string
   User:
     properties:
+      id:
+        type: string
       nickname:
         type: string
       avatar:
diff --git a/swagger_py_codegen/templates/falcon/api.tpl b/swagger_py_codegen/templates/falcon/api.tpl
@@ -1,34 +1,32 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import, print_function
 
-from six import with_metaclass
-import six
-import falcon
+import inspect
 
-from ..validators import  request_validate, response_filter
+from sanic.views import HTTPMethodView
 
-import inspect
+from ..validators import request_validate, response_filter
 
 before_decorators = [request_validate]
 after_decorators = [response_filter]
 
-
-if six.PY3:
-    ismethod = inspect.isfunction
-else:
-    ismethod = inspect.ismethod
+methods = ['get', 'put', 'post', 'delete']
 
 
 def add_before_decorators(model_class):
-    for name, m in inspect.getmembers(model_class, ismethod):
-        if name in ['on_get', 'on_post', 'on_put', 'on_delete']:
-            setattr(model_class, name, falcon.before(*before_decorators)(m))
+    for name, m in inspect.getmembers(model_class, inspect.isfunction):
+        if name in methods:
+            for dec in before_decorators:
+                m = dec(m)
+            setattr(model_class, name, m)
 
 
 def add_after_decorators(model_class):
-    for name, m in inspect.getmembers(model_class, ismethod):
-        if name in ['on_get', 'on_post', 'on_put', 'on_delete']:
-            setattr(model_class, name, falcon.after(*after_decorators)(m))
+    for name, m in inspect.getmembers(model_class, inspect.isfunction):
+        if name in methods:
+            for dec in after_decorators:
+                m = dec(m)
+            setattr(model_class, name, m)
 
 
 class APIMetaclass(type):
@@ -40,6 +38,8 @@ class APIMetaclass(type):
         add_before_decorators(cls)
         add_after_decorators(cls)
 
-class Resource(with_metaclass(APIMetaclass, object)):
 
-    pass
+class Resource(HTTPMethodView, metaclass=APIMetaclass):
+
+
+    pass
diff --git a/swagger_py_codegen/templates/falcon/validators.tpl b/swagger_py_codegen/templates/falcon/validators.tpl
@@ -1,32 +1,57 @@
 # -*- coding: utf-8 -*-
 
-{% include '_do_not_change.tpl' %}
+###
+### DO NOT CHANGE THIS FILE
+###
+### The code is auto generated, your change will be overwritten by
+### code generating.
+###
 from __future__ import absolute_import, print_function
 
+import re
 import json
 from datetime import date
 from functools import wraps
 
 import six
-import falcon
+from sanic import response
+from sanic.exceptions import ServerError
+from sanic.response import HTTPResponse
 
 from werkzeug.datastructures import MultiDict, Headers
+from sanic.request import RequestParameters
 from jsonschema import Draft4Validator
 
 from .schemas import (
     validators, filters, scopes, security, base_path, normalize)
 
 
-if six.PY3:
-    def _remove_characters(text, deletechars):
-        return text.translate({ord(x): None for x in deletechars})
-else:
-    def _remove_characters(text, deletechars):
-        return text.translate(None, deletechars)
+def unpack(value):
+    """Return a three tuple of data, code, and headers"""
+    if not isinstance(value, tuple):
+        return value, 200, {}
+
+    try:
+        data, code, headers = value
+        return data, code, headers
+    except ValueError:
+        pass
+
+    try:
+        data, code = value
+        return data, code, {}
+    except ValueError:
+        pass
+
+    return value, 200, {}
+
+
+def _remove_characters(text, deletechars):
+    return text.translate({ord(x): None for x in deletechars})
 
 
 def _path_to_endpoint(path):
-    endpoint = path.strip('/').replace('/', '_').replace('-', '_')
+    endpoint = '_'.join(filter(None, re.sub(r'(/|<|>|-)', r'_', path).split('_')))
     _base_path = base_path.strip('/').replace('/', '_').replace('-', '_')
     if endpoint.startswith(_base_path):
         endpoint = endpoint[len(_base_path)+1:]
@@ -41,7 +66,7 @@ class JSONEncoder(json.JSONEncoder):
         return json.JSONEncoder.default(self, o)
 
 
-class FalconValidatorAdaptor(object):
+class SanicValidatorAdaptor(object):
 
     def __init__(self, schema):
         self.validator = Draft4Validator(schema)
@@ -55,10 +80,10 @@ class FalconValidatorAdaptor(object):
     def type_convert(self, obj):
         if obj is None:
             return None
-        if isinstance(obj, (dict, list)) and not isinstance(obj, MultiDict):
+        if isinstance(obj, (dict, list)) and not isinstance(obj, RequestParameters):
             return obj
         if isinstance(obj, Headers):
-            obj = MultiDict(six.iteritems(obj))
+            obj = MultiDict(obj.items())
         result = dict()
 
         convert_funs = {
@@ -73,7 +98,7 @@ class FalconValidatorAdaptor(object):
             func = convert_funs.get(type_, lambda v: v[0])
             return [func([i]) for i in v]
 
-        for k, values in obj.lists():
+        for k, values in obj.items():
             prop = self.validator.schema['properties'].get(k, {})
             type_ = prop.get('type')
             fun = convert_funs.get(type_, lambda v: v[0])
@@ -86,83 +111,82 @@ class FalconValidatorAdaptor(object):
 
     def validate(self, value):
         value = self.type_convert(value)
-        errors = {e.path[0]: e.message for e in self.validator.iter_errors(value)}
+        errors = list(e.message for e in self.validator.iter_errors(value))
         return normalize(self.validator.schema, value)[0], errors
 
 
-def request_validate(req, resp, resource, params):
-
-    endpoint = _path_to_endpoint(req.uri_template)
-    # scope
-    if (endpoint, req.method) in scopes and not set(
-            scopes[(endpoint, req.method)]).issubset(set(security.scopes)):
-        falcon.HTTPUnauthorized('403403403')
-    # data
-    method = req.method
-    if method == 'HEAD':
-        method = 'GET'
-    locations = validators.get((endpoint, method), {})
-    context = {}
-    for location, schema in six.iteritems(locations):
-        value = getattr(req, location, MultiDict())
-        if location == 'headers':
-            value = {k.capitalize(): v for k, v in value.items()}
-        elif location == 'json':
-            body = req.stream.read()
-
-            try:
-                value = json.loads(body.decode('utf-8'))
-            except (ValueError, UnicodeDecodeError):
-                raise falcon.HTTPError(falcon.HTTP_753,
-                                       'Malformed JSON',
-                                       'Could not decode the request body. The '
-                                       'JSON was incorrect or not encoded as '
-                                       'UTF-8.')
-        if value is None:
-            value = MultiDict()
-        validator = FalconValidatorAdaptor(schema)
-        result, errors = validator.validate(value)
-        if errors:
-            raise falcon.HTTPUnprocessableEntity('Unprocessable Entity', description=errors)
-        context[location] = result
-    req.context = context
-
+def request_validate(view):
+
+    @wraps(view)
+    def wrapper(*args, **kwargs):
+        request = args[1]
+        endpoint = _path_to_endpoint(request.uri_template)
+        # scope
+        if (endpoint, request.method) in scopes and not set(
+                scopes[(endpoint, request.method)]).issubset(set(security.scopes)):
+            raise ServerError('403', status_code=403)
+        # data
+        method = request.method
+        if method == 'HEAD':
+            method = 'GET'
+        locations = validators.get((endpoint, method), {})
+        for location, schema in locations.items():
+            value = getattr(request, location, MultiDict())
+            if value is None:
+                value = MultiDict()
+            validator = SanicValidatorAdaptor(schema)
+            result, errors = validator.validate(value)
+            if errors:
+                raise ServerError('Unprocessable Entity', status_code=422)
+            request[location] = result
+        return view(*args, **kwargs)
+
+    return wrapper
+
+
+def response_filter(view):
+
+    @wraps(view)
+    def wrapper(*args, **kwargs):
+        request = args[1]
+        resp = view(*args, **kwargs)
+
+        if isinstance(resp, HTTPResponse):
+            return resp
+
+        endpoint = _path_to_endpoint(request.uri_template)
+        method = request.method
+        if method == 'HEAD':
+            method = 'GET'
+        filter = filters.get((endpoint, method), None)
+        if not filter:
+            return resp
+
+        headers = None
+        status = None
+        if isinstance(resp, tuple):
+            resp, status, headers = unpack(resp)
+
+        if len(filter) == 1:
+            status = list(filter.keys())[0]
 
-def response_filter(req, resp, resource):
+        schemas = filter.get(status)
+        if not schemas:
+            # return resp, status, headers
+            raise ServerError('`%d` is not a defined status code.' % status, 500)
 
-    endpoint = _path_to_endpoint(req.uri_template)
-    method = req.method
-    if method == 'HEAD':
-        method = 'GET'
-    filter = filters.get((endpoint, method), None)
-    if not filter:
-        return resp
+        resp, errors = normalize(schemas['schema'], resp)
+        if schemas['headers']:
+            headers, header_errors = normalize(
+                {'properties': schemas['headers']}, headers)
+            errors.extend(header_errors)
+        if errors:
+            raise ServerError('Expectation Failed', 500)
 
-    headers = None
-    status = None
+        return response.json(
+            resp,
+            status=status,
+            headers=headers,
+        )
 
-    if len(filter) == 1:
-        if six.PY3:
-            status = list(filter.keys())[0]
-        else:
-            status = filter.keys()[0]
-
-    schemas = filter.get(status)
-    if not schemas:
-        # return resp, status, headers
-        raise falcon.HTTPInternalServerError(
-            'Not defined',
-            description='`%d` is not a defined status code.' % status)
-
-    _resp, errors = normalize(schemas['schema'], req.context['result'])
-    if schemas['headers']:
-        headers, header_errors = normalize(
-            {'properties': schemas['headers']}, headers)
-        errors.extend(header_errors)
-    if errors:
-        raise falcon.HTTPInternalServerError(title='Expectation Failed',
-                                             description=errors)
-
-    if 'result' not in req.context:
-        return
-    resp.body = json.dumps(_resp)
+    return wrapper
diff --git a/swagger_py_codegen/templates/sanic/app.tpl b/swagger_py_codegen/templates/sanic/app.tpl
@@ -8,14 +8,28 @@ import {{ blueprint }}
 
 def create_app():
     app = Sanic(__name__)
-    app.register_blueprint(
-        {{ blueprint }}.bp,
-        url_prefix='{{ base_path }}')
+    app.static('/static', './static')
+    app.blueprint({{ blueprint }}.bp)
     return app
 
 
 app = create_app()
 
+@app.exception(NotFound)
+def not_found(request, exception):
+    return json({'error_code': 'not_found',
+                 'message': exception.args[0]},
+                status=exception.status_code,
+                )
+
+
+@app.exception(InvalidUsage)
+def method_not_allow(request, exception):
+    return json({'error_code': 'method_not_allow',
+                 'message': exception.args[0]},
+                status=exception.status_code,
+                )
+
 
 if __name__ == '__main__':
     app.run(host="0.0.0.0", port=8000)
diff --git a/swagger_py_codegen/templates/sanic/validators.tpl b/swagger_py_codegen/templates/sanic/validators.tpl
diff --git a/tests/test_sanic.py b/tests/test_sanic.py
