def create_oauth(app): spf = SanicPluginsFramework(app) try: oauth = spf.register_plugin(oauthclient) except ValueError as v: _, oauth = v return oauth
def api(self, app): blueprint = Blueprint('api', __name__) spf = SanicPluginsFramework(blueprint) plugin, reg = spf.register_plugin(restplus) api = Api(reg) app.register_blueprint(blueprint) yield api
def sqlalchemy_provider(app): spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauth2provider) bind_sqlalchemy(oauth, db.session, user=User, token=Token, client=Client, grant=Grant, current_user=current_user) return oauth
def add_oauth_plugin(app): spf = SanicPluginsFramework(app) try: oauth = spf.register_plugin(oauthclient) except ValueError as v: _, oauth = v.args return oauth
def test_middleware_response(): app = Sanic('test_middleware_response') spf = SanicPluginsFramework(app) plugin = TestPlugin() results = [] @plugin.middleware('request') async def process_response(request): results.append(request) @plugin.middleware('response') async def process_response(request, response): results.append(request) results.append(response) @plugin.route('/') async def handler(request): return text('OK') spf.register_plugin(plugin) request, response = app.test_client.get('/') assert response.text == 'OK' assert type(results[0]) is Request assert type(results[1]) is Request assert isinstance(results[2], HTTPResponse)
def test_lazy_load(self): twitter = oauthclient.remote_app( 'twitter', base_url='https://api.twitter.com/1/', app_key='twitter' ) assert twitter.base_url == 'https://api.twitter.com/1/' app = Sanic(__name__) app.config.update({ 'twitter': dict( request_token_params={'realms': 'email'}, consumer_key='twitter key', consumer_secret='twitter secret', request_token_url='request url', access_token_url='token url', authorize_url='auth url', ) }) spf = SanicPluginsFramework(app) spf.register_plugin(oauthclient) assert twitter.consumer_key == 'twitter key' assert twitter.consumer_secret == 'twitter secret' assert twitter.request_token_url == 'request url' assert twitter.access_token_url == 'token url' assert twitter.authorize_url == 'auth url' assert twitter.content_type is None assert 'realms' in twitter.request_token_params
def test_plugin_urlfor_1(): app = Sanic('test_plugin_urlfor_1') spf = SanicPluginsFramework(app) spf.register_plugin(test_plugin) client = app.test_client resp = client.get('/t2') assert resp[1].text == 't1'
def test_raise_app(): with raises(AttributeError): app = Sanic(__name__) spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauthclient) plugin = app.extensions['oauthlib.client'] client = spf.get_plugin_assoc(plugin) assert client.demo.name == 'dev'
def cache_provider(app): spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauth2provider) bind_sqlalchemy(oauth, db.session, user=User, token=Token, client=Client, current_user=current_user) app.config.update({'OAUTH2_CACHE_TYPE': 'simple'}) bind_cache_grant(app, oauth, current_user) return oauth
def create_app(): LOG_CONFIG = copy(LOGGING_CONFIG_DEFAULTS) LOG_CONFIG['loggers']['sanic.error'][ 'level'] = "WARNING" # Default is INFO LOG_CONFIG['loggers']['sanic.access'][ 'level'] = "WARNING" # Default is INFO app = Sanic(__name__, log_config=LOG_CONFIG, configure_logging=True) spf = SanicPluginsFramework(app) app.config['LOGO'] = r""" _ ___ ____ ___ ___ _ _ _____ _____ ____ ____ _ _____ ___ ____ _ ____ ___ | | / _ \ / ___|_ _| |_ _| \ | |_ _| ____/ ___| _ \ / \|_ _/ _ \| _ \ / \ | _ |_ _| | | | | | | | | | | || \| | | | | _|| | _| |_) | / _ \ | || | | | |_) | / _ \ | |_) | | | |__| |_| | |___ | | | || |\ | | | | |__| |_| | _ < / ___ \| || |_| | _ < / ___ \| __/| | |_____\___/ \____|___| |___|_| \_| |_| |_____\____|_| \_/_/ \_|_| \___/|_| \_\ /_/ \_|_| |___| git commit: {} """.format(gitlabel) app.config.SWAGGER_UI_DOC_EXPANSION = 'list' app.config.RESPONSE_TIMEOUT = 4800 # Register/Activate Sanic-CORS plugin with allow all origins _ = spf.register_plugin(cors, origins=r".*", automatic_options=True) # Register/Activate Sanic-Restplus plugin restplus_associated = spf.register_plugin(restplus, _url_prefix="api") # Remove any previous apps from the api instance. # (this is needed during testing, the test runner does calls create_app many times) api_v1.spf_reg = None # Register our LOCI Api on the restplus plugin restplus_associated.api(api_v1) # Make the static directory available to be served via the /static/ route if needed # Note, it is preferred that something like apache or nginx does static file serving in production dir_loc = os.path.abspath(os.path.join(HERE_DIR, "static")) app.static(uri="/static/", file_or_directory=dir_loc, name="material_swagger") @app.route("/") def index(request): """ Route function for the index route. Only exists to point a wayward user to the api swagger doc page. :param request: :type request: Request :return: :rtype: HTTPResponse """ html = "<h1>LOCI Integration API</h1>\ <a href=\"api/v1/doc\">Click here to go to the swaggerui doc page.</a>\ <pre>Git commit: <a href=\"{prefix}{commit}\">{commit}</a></pre>".format( prefix= "https://github.com/CSIRO-enviro-informatics/loci-integration-api/commit/", commit=str(gitlabel)) return HTTPResponse(html, status=200, content_type="text/html") return app
def default_provider(app): spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauth2provider) @oauth.clientgetter def get_client(client_id): return db.session.query(Client).filter_by(client_id=client_id).first() @oauth.grantgetter def get_grant(client_id, code): return db.session.query(Grant).filter_by(client_id=client_id, code=code).first() @oauth.tokengetter def get_token(access_token=None, refresh_token=None): if access_token: return db.session.query(Token).filter_by(access_token=access_token).first() if refresh_token: return db.session.query(Token).filter_by(refresh_token=refresh_token).first() return None @oauth.grantsetter def set_grant(client_id, code, request, *args, **kwargs): expires = datetime.utcnow() + timedelta(seconds=100) grant = Grant( client_id=client_id, code=code['code'], redirect_uri=request.redirect_uri, scope=' '.join(request.scopes), user_id=g.user.id, expires=expires, ) db.session.add(grant) db.session.commit() @oauth.tokensetter def set_token(token, request, *args, **kwargs): # In real project, a token is unique bound to user and client. # Which means, you don't need to create a token every time. tok = Token(**token) if request.response_type == 'token': tok.user_id = g.user.id else: tok.user_id = request.user.id tok.client_id = request.client.client_id db.session.add(tok) db.session.commit() @oauth.usergetter def get_user(username, password, *args, **kwargs): # This is optional, if you don't need password credential # there is no need to implement this method user = db.session.query(User).filter_by(username=username).first() if user and user.check_password(password): return user return None return oauth
def test_plugin_log1(): app = Sanic('test_plugin_log1') spf = SanicPluginsFramework(app) plugin = spf.register_plugin(test_plugin) client = app.test_client exceptions = None try: resp = client.get('/t1') except Exception as e: exceptions = e assert exceptions is None
def test_spf_singleton_2(): """ Registering the framework twice, but with different apps should return two different spfs :return: """ app1 = Sanic('test_spf_singleton_2_1') spf1 = SanicPluginsFramework(app1) app2 = Sanic('test_spf_singleton_2_1') spf1.register_plugin(instance) spf2 = SanicPluginsFramework(app2) assert spf1 != spf2
def wrapped_decorator(f): spf = SanicPluginsFramework(app) # get the singleton from the app try: plugin = spf.register_plugin(cors, skip_reg=True) except ValueError as e: # this is normal, if this plugin has been registered previously assert e.args and len(e.args) > 1 plugin = e.args[1] context = cors.get_context_from_spf(spf) log = context.log log(logging.DEBUG, "Enabled {:s} for cross_origin using options: {}".format(str(f), str(_options))) return _real_decorator(f)
def test_spf_singleton_1(): """ Registering the framework twice on the same app should return an indentical instance of the spf :return: """ app = Sanic('test_spf_singleton_1') spf = SanicPluginsFramework(app) spf.register_plugin(instance) spf2 = SanicPluginsFramework(app) assert spf == spf2
def create_client(self, app): spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauthclient) remote = oauth.remote_app( 'dev', consumer_key='noclient', consumer_secret='dev', request_token_params={'realm': 'email'}, base_url='http://localhost/api/', request_token_url='http://localhost/oauth/request_token', access_token_method='GET', access_token_url='http://localhost/oauth/access_token', authorize_url='http://localhost/oauth/authorize') return create_client(app, remote)
def create_app(): app = Sanic(__name__) spf = SanicPluginsFramework(app) app.config['LOGO'] = r""" _ ___ ____ ___ ___ _ _ _____ _____ ____ ____ _ _____ ___ ____ _ ____ ___ | | / _ \ / ___|_ _| |_ _| \ | |_ _| ____/ ___| _ \ / \|_ _/ _ \| _ \ / \ | _ |_ _| | | | | | | | | | | || \| | | | | _|| | _| |_) | / _ \ | || | | | |_) | / _ \ | |_) | | | |__| |_| | |___ | | | || |\ | | | | |__| |_| | _ < / ___ \| || |_| | _ < / ___ \| __/| | |_____\___/ \____|___| |___|_| \_| |_| |_____\____|_| \_/_/ \_|_| \___/|_| \_\ /_/ \_|_| |___|prod """ app.config.SWAGGER_UI_DOC_EXPANSION = 'list' # Register/Activate Sanic-CORS plugin with allow all origins _ = spf.register_plugin(cors, origins=r".*", automatic_options=True) # Register/Activate Sanic-Restplus plugin restplus_associated = spf.register_plugin(restplus) # Remove any previous apps from the api instance. api_v1.spf_reg = None # Register our LOCI Api on the restplus plugin restplus_associated.api(api_v1) # Make the static directory available to be served via the /static/ route if needed # Note, it is preferred that something like apache or nginx does static file serving in production dir_loc = os.path.abspath(os.path.join(HERE_DIR, "static")) app.static(uri="/static/", file_or_directory=dir_loc, name="material_swagger") @app.route("/") def index(request): """ Route function for the index route. Only exists to point a wayward user to the api swagger doc page. :param request: :type request: Request :return: :rtype: HTTPResponse """ html = "<h1>LOCI Integration API</h1>\ <a href=\"api/v1/doc\">Click here to go to the swaggerui doc page.</a>" return HTTPResponse(html, status=200, content_type="text/html") return app
def test_app(request): app = Sanic(request.node.name) spf = SanicPluginsFramework(app) oauth = spf.register_plugin(oauthclient) remote = oauth.remote_app( 'dev', consumer_key='dev', consumer_secret='dev', request_token_params={'scope': 'email'}, base_url='http://127.0.0.1:5000/api/', request_token_url=None, access_token_method='POST', access_token_url='http://127.0.0.1:5000/oauth/token', authorize_url='http://127.0.0.1:5000/oauth/authorize') plugin = app.extensions['oauthlib.client'] client = spf.get_plugin_assoc(plugin) assert client.dev.name == 'dev'
def test_middleware_override_request(): app = Sanic('test_middleware_override_request') spf = SanicPluginsFramework(app) plugin = TestPlugin() @plugin.middleware async def halt_request(request): return text('OK') @plugin.route('/') async def handler(request): return text('FAIL') spf.register_plugin(plugin) response = app.test_client.get('/', gather_request=False) assert response.status == 200 assert response.text == 'OK'
def test_lazy_load_with_plain_text_config(self): twitter = oauthclient.remote_app('twitter', app_key='TWITTER') app = Sanic(__name__) app.config['TWITTER_CONSUMER_KEY'] = 'twitter key' app.config['TWITTER_CONSUMER_SECRET'] = 'twitter secret' app.config['TWITTER_REQUEST_TOKEN_URL'] = 'request url' app.config['TWITTER_ACCESS_TOKEN_URL'] = 'token url' app.config['TWITTER_AUTHORIZE_URL'] = 'auth url' spf = SanicPluginsFramework(app) spf.register_plugin(oauthclient) assert twitter.consumer_key == 'twitter key' assert twitter.consumer_secret == 'twitter secret' assert twitter.request_token_url == 'request url' assert twitter.access_token_url == 'token url' assert twitter.authorize_url == 'auth url'
def test_plugin_url_attributes(path, query, expected_url): app = Sanic('test_plugin_url_attrs') spf = SanicPluginsFramework(app) test_plugin = TestPlugin() async def handler(request): return text('OK') test_plugin.route(path)(handler) spf.register_plugin(test_plugin) request, response = app.test_client.get(path + '?{}'.format(query)) assert request.url == expected_url.format(HOST, PORT) parsed = urlparse(request.url) assert parsed.scheme == request.scheme assert parsed.path == request.path assert parsed.query == request.query_string assert parsed.netloc == request.host
def test_plugin_ws_url_attributes(path, query, expected_url): """Note, this doesn't _really_ test websocket functionality very well.""" app = Sanic('test_plugin_ws_url_attrs') spf = SanicPluginsFramework(app) test_plugin = TestPlugin() async def handler(request): return text('OK') test_plugin.websocket(path)(handler) spf.register_plugin(test_plugin) request, response = app.test_client.get(path + '?{}'.format(query)) assert request.url == expected_url.format(HOST, PORT) parsed = urlparse(request.url) assert parsed.scheme == request.scheme assert parsed.path == request.path assert parsed.query == request.query_string assert parsed.netloc == request.host
def test_middleware_order(): app = Sanic('test_middleware_order') spf = SanicPluginsFramework(app) plugin = TestPlugin() order = [] @plugin.middleware('request') async def request1(request): order.append(1) @plugin.middleware('request') async def request2(request): order.append(2) @plugin.middleware('request') async def request3(request): order.append(3) @plugin.middleware('response') async def response1(request, response): order.append(6) @plugin.middleware('response') async def response2(request, response): order.append(5) @plugin.middleware('response') async def response3(request, response): order.append(4) @plugin.route('/') async def handler(request): return text('OK') spf.register_plugin(plugin) request, response = app.test_client.get('/') assert response.status == 200 assert order == [1, 2, 3, 4, 5, 6]
def test_middleware_response_exception(): app = Sanic('test_middleware_response_exception') spf = SanicPluginsFramework(app) plugin = TestPlugin() result = {'status_code': None} @plugin.middleware('response') async def process_response(reqest, response): result['status_code'] = response.status return response @plugin.exception(NotFound) async def error_handler(request, exception): return text('OK', exception.status_code) @plugin.route('/') async def handler(request): return text('FAIL') spf.register_plugin(plugin) request, response = app.test_client.get('/page_not_found') assert response.text == 'OK' assert result['status_code'] == 404
def api(self, reg, *args, api_class=None, **kwargs): from .api import Api if isinstance(reg, PluginAssociated): (pl, reg) = reg (spf, _, _) = reg elif isinstance(reg, PluginRegistration): (spf, _, _) = reg elif isinstance(reg, SanicPluginsFramework): spf = reg reg = self.find_plugin_registration(spf) elif isinstance(reg, Sanic): app = reg spf = SanicPluginsFramework(app) reg = self.find_plugin_registration(spf) else: raise RuntimeError( "the 'reg' argument must be a SPF, an Association, Registration, or an App!" ) context = self.get_context_from_spf(reg) app = context.app assert isinstance(app, (Sanic, Blueprint)) if api_class is None: if args and len(args) > 0 and isinstance(args[0], Api): args = list(args) api_class = args.pop(0) else: api_class = Api if isinstance(api_class, type): if app in args: # don't want app in here! args = list(args) args.remove(app) assert issubclass(api_class, Api) api = api_class(*args, **kwargs) kwargs = dict() else: api = api_class assert isinstance(api, Api) api.init_api(reg, **kwargs) context.apis.add(api) return api
from sanic import Sanic from sanic.response import text from sanic.exceptions import InvalidUsage, ServerError, NotFound from sanic.handlers import ErrorHandler from spf import SanicPlugin, SanicPluginsFramework class TestPlugin(SanicPlugin): pass # The following tests are taken directly from Sanic source @ v0.6.0 # and modified to test the SanicPlugin, rather than Sanic exception_handler_app = Sanic('test_exception_handler') spf = SanicPluginsFramework(exception_handler_app) test_plugin = TestPlugin() @test_plugin.route('/1') def handler_1(request): raise InvalidUsage("OK") @test_plugin.route('/2') def handler_2(request): raise ServerError("OK") @test_plugin.route('/3') def handler_3(request):
def spf(request): a = app_with_name(request.node.name) return SanicPluginsFramework(a)
def __init__(self, spf_reg=None, version='1.0', title=None, description=None, terms_url=None, license=None, license_url=None, contact=None, contact_url=None, contact_email=None, authorizations=None, security=None, doc='/', default_id=default_id, default='default', default_label='Default namespace', validate=None, tags=None, prefix='', ordered=False, default_mediatype='application/json', decorators=None, catch_all_404s=False, serve_challenge_on_401=False, format_checker=None, additional_css=None, **kwargs): self.version = version self.title = title or 'API' self.description = description self.terms_url = terms_url self.contact = contact self.contact_email = contact_email self.contact_url = contact_url self.license = license self.license_url = license_url self.authorizations = authorizations self.security = security self.default_id = default_id self.ordered = ordered self._validate = validate self._doc = doc self._doc_view = None self._default_error_handler = None self.tags = tags or [] self.error_handlers = { ParseError: mask_parse_error_handler, MaskError: mask_error_handler, } self._schema = None self.models = {} self._refresolver = None self.format_checker = format_checker self.namespaces = [] self.default_namespace = self.namespace( default, default_label, endpoint='{0}-declaration'.format(default), validate=validate, api=self, path='/', ) self.ns_paths = dict() if py_36 > cur_py_version: #py3.5 or below self.representations = OrderedDict(DEFAULT_REPRESENTATIONS) else: self.representations = dict(DEFAULT_REPRESENTATIONS) self.urls = {} self.prefix = prefix self.default_mediatype = default_mediatype self.decorators = decorators if decorators else [] self.catch_all_404s = catch_all_404s self.serve_challenge_on_401 = serve_challenge_on_401 self.blueprint_setup = None self.endpoints = set() self.resources = [] self.spf_reg = None self.blueprint = None self.additional_css = additional_css Api.uid_counter += 1 self._uid = Api.uid_counter if spf_reg is not None: if isinstance(spf_reg, Sanic): # use legacy init method spf = SanicPluginsFramework(spf_reg) try: spf_reg = restplus.find_plugin_registration(spf) except LookupError: raise RuntimeError( "Cannot create Api before sanic_restplus is registered on the SPF." ) self.init_api(reg=spf_reg, **kwargs)
def create_app(self): client_app = Sanic(__name__) server_app = Sanic(__name__) spf1 = SanicPluginsFramework(client_app) spf2 = SanicPluginsFramework(server_app) return server_app, client_app
from sanic import Sanic from sanic.response import text from spf import SanicPluginsFramework #from examples.my_plugin import my_plugin from examples import my_plugin from examples.my_plugin import MyPlugin from logging import DEBUG app = Sanic(__name__) # mp = MyPlugin(app) //Legacy registration example spf = SanicPluginsFramework(app) my_plugin = spf.register_plugin(my_plugin) @app.route('/') def index(request): return text("hello world") if __name__ == "__main__": app.run("127.0.0.1", port=8098, debug=True)