def test_aborting(self):
class Foo(Exception):
whatever = 42
app = flask.Flask(__name__)
app.testing = True
@app.errorhandler(Foo)
def handle_foo(e):
return str(e.whatever)
@app.route('/')
def index():
raise flask.abort(flask.redirect(flask.url_for('test')))
@app.route('/test')
def test():
raise Foo()
with app.test_client() as c:
rv = c.get('/')
self.assertEqual(rv.headers['Location'], 'http://localhost/test')
rv = c.get('/test')
self.assertEqual(rv.data, b'42')
python类abort()的实例源码
def validate_room_jwt(function=None, requires_jamf_configured=True):
def decorator(f):
@functools.wraps(f)
def wrapper(*args, **kwargs):
try:
token = flask.request.headers.get('Authorization').split()[1]
except:
flask.abort(401)
hipchat_room = verify_jwt(token)
if requires_jamf_configured and not hipchat_room.jamf_configured:
message = "You must first configure a Jamf Pro service account to use this feature."
send_notification(hipchat_room.hipchat_token, hipchat_room.hipchat_room_id, message, color='yellow')
flask.abort(400)
return f(hipchat_room, *args, **kwargs)
return wrapper
return decorator(function) if function else decorator
def _dispatch(self, route, **kwargs):
user = None
if 'shared_id' in session:
if session['shared_id'] in self.user_tracker.user_refs:
user = self.user_tracker.users[session['shared_id']]
if user is None:
user = self.user_tracker.connect_user()
session['shared_id'] = user.id_
user.open_page(route, kwargs)
ctx = CallCTX(abort=abort)
user.active_controller.before_connect(ctx)
ctx.deactivate()
possible = user.active_controller.render_page()
if user.active_controller.special_return_handler is not None:
return user.active_controller.special_return_handler()
return possible
def role_assignment_add(name):
"""Assign role to user (POST handler)"""
db = flask.current_app.container.get('db')
login = flask.request.form.get('login', '')
user = db.session.query(User).filter_by(login=login).first()
role = db.session.query(Role).filter_by(name=name).first()
if user is None or role is None:
flask.abort(404)
account = user.user_account
if account in role.user_accounts:
flask.flash('User {} already has role {}'.format(login, name),
'error')
else:
role.user_accounts.append(account)
db.session.commit()
flask.flash('Role {} assigned to user {}'.format(name, login),
'success')
return flask.redirect(flask.url_for('admin.role_detail', name=name))
def role_assignment_remove(name):
"""Remove assignment of role to user (POST handler)"""
db = flask.current_app.container.get('db')
login = flask.request.form.get('login', '')
user = db.session.query(User).filter_by(login=login).first()
role = db.session.query(Role).filter_by(name=name).first()
if user is None or role is None:
flask.abort(404)
account = user.user_account
if account not in role.user_accounts:
flask.flash('User {} doesn\'t have role {}'.format(login, name),
'error')
else:
role.user_accounts.remove(account)
db.session.commit()
flask.flash('Role {} removed from user {}'.format(name, login),
'success')
return flask.redirect(flask.url_for('admin.role_detail', name=name))
def org_detail(login):
"""Organization detail (GET handler)
.. todo:: implement 410 (org deleted/archived/renamed)
"""
db = flask.current_app.container.get('db')
ext_master = flask.current_app.container.get('ext_master')
org = db.session.query(Organization).filter_by(login=login).first()
if org is None:
user = db.session.query(User).filter_by(login=login).first()
if user is None:
flask.abort(404)
flask.flash('Oy! You wanted to access organization, but it\'s auser.'
'We redirected you but be careful next time!', 'notice')
return flask.redirect(flask.url_for('core.user_detail', login=login))
tabs = {}
ext_master.call('view_core_org_detail_tabs',
org=org, tabs_dict=tabs)
tabs = sorted(tabs.values())
active_tab = flask.request.args.get('tab', tabs[0].id)
return flask.render_template(
'core/org.html', org=org, tabs=tabs, active_tab=active_tab
)
def test_error_handling(self):
app = flask.Flask(__name__)
admin = flask.Module(__name__, 'admin')
@admin.app_errorhandler(404)
def not_found(e):
return 'not found', 404
@admin.app_errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@admin.route('/')
def index():
flask.abort(404)
@admin.route('/error')
def error():
1 // 0
app.register_module(admin)
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def test_error_handling(self):
app = flask.Flask(__name__)
@app.errorhandler(404)
def not_found(e):
return 'not found', 404
@app.errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@app.route('/')
def index():
flask.abort(404)
@app.route('/error')
def error():
1 // 0
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def test_aborting(self):
class Foo(Exception):
whatever = 42
app = flask.Flask(__name__)
app.testing = True
@app.errorhandler(Foo)
def handle_foo(e):
return str(e.whatever)
@app.route('/')
def index():
raise flask.abort(flask.redirect(flask.url_for('test')))
@app.route('/test')
def test():
raise Foo()
with app.test_client() as c:
rv = c.get('/')
self.assertEqual(rv.headers['Location'], 'http://localhost/test')
rv = c.get('/test')
self.assertEqual(rv.data, b'42')
def test_error_handling(self):
app = flask.Flask(__name__)
admin = flask.Module(__name__, 'admin')
@admin.app_errorhandler(404)
def not_found(e):
return 'not found', 404
@admin.app_errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@admin.route('/')
def index():
flask.abort(404)
@admin.route('/error')
def error():
1 // 0
app.register_module(admin)
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def test_error_handling(self):
app = flask.Flask(__name__)
@app.errorhandler(404)
def not_found(e):
return 'not found', 404
@app.errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@app.route('/')
def index():
flask.abort(404)
@app.route('/error')
def error():
1 // 0
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def test_aborting(self):
class Foo(Exception):
whatever = 42
app = flask.Flask(__name__)
app.testing = True
@app.errorhandler(Foo)
def handle_foo(e):
return str(e.whatever)
@app.route('/')
def index():
raise flask.abort(flask.redirect(flask.url_for('test')))
@app.route('/test')
def test():
raise Foo()
with app.test_client() as c:
rv = c.get('/')
self.assertEqual(rv.headers['Location'], 'http://localhost/test')
rv = c.get('/test')
self.assertEqual(rv.data, b'42')
def post(self):
args = parser.parse({
'username': wf.Str(missing=None),
'email': wf.Str(missing=None),
'password': wf.Str(missing=None),
})
username = args['username'] or args['email']
password = args['password']
if not username or not password:
return flask.abort(400)
if username.find('@') > 0:
user_db = model.User.get_by('email', username.lower())
else:
user_db = model.User.get_by('username', username.lower())
if user_db and user_db.password_hash == util.password_hash(user_db, password):
auth.signin_user_db(user_db)
return helpers.make_response(user_db, model.User.FIELDS)
return flask.abort(401)
def project_view(project_id):
project_db = model.Project.get_by_id(project_id)
if not project_db or project_db.user_key != auth.current_user_key():
flask.abort(404)
crash_dbs, crash_cursor = project_db.get_crash_dbs(
order=util.param('order') or '-created',
)
return flask.render_template(
'project/project_view.html',
html_class='project-view',
title=project_db.name,
project_db=project_db,
crash_dbs=crash_dbs,
next_url=util.generate_next_url(crash_cursor),
api_url=flask.url_for('api.project', project_key=project_db.key.urlsafe() if project_db.key else ''),
)
###############################################################################
# Admin List
###############################################################################
def admin_project_update(project_id=0):
if project_id:
project_db = model.Project.get_by_id(project_id)
else:
project_db = model.Project(user_key=auth.current_user_key())
if not project_db:
flask.abort(404)
form = ProjectUpdateAdminForm(obj=project_db)
if form.validate_on_submit():
form.populate_obj(project_db)
project_db.put()
return flask.redirect(flask.url_for('admin_project_list', order='-modified'))
return flask.render_template(
'project/admin_project_update.html',
title=project_db.name,
html_class='admin-project-update',
form=form,
project_db=project_db,
back_url_for='admin_project_list',
api_url=flask.url_for('api.admin.project', project_key=project_db.key.urlsafe() if project_db.key else ''),
)
def admin_test(test=None):
if test and test not in TESTS:
flask.abort(404)
form = TestForm()
if form.validate_on_submit():
pass
return flask.render_template(
'test/test_one.html' if test else 'test/test.html',
title='Test: %s' % test.title() if test else 'Test',
html_class='test',
form=form,
test=test,
tests=TESTS,
back_url_for='admin_test' if test else None,
)
def test_error_handling(self):
app = flask.Flask(__name__)
admin = flask.Module(__name__, 'admin')
@admin.app_errorhandler(404)
def not_found(e):
return 'not found', 404
@admin.app_errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@admin.route('/')
def index():
flask.abort(404)
@admin.route('/error')
def error():
1 // 0
app.register_module(admin)
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def test_error_handling(self):
app = flask.Flask(__name__)
@app.errorhandler(404)
def not_found(e):
return 'not found', 404
@app.errorhandler(500)
def internal_server_error(e):
return 'internal server error', 500
@app.route('/')
def index():
flask.abort(404)
@app.route('/error')
def error():
1 // 0
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, b'not found')
rv = c.get('/error')
self.assert_equal(rv.status_code, 500)
self.assert_equal(b'internal server error', rv.data)
def backup(username:str, timeframe:str, backup_date:str):
"""
Route: /backup/username/timeframe/backup_date
This route returns the requested backup.
:param username the server username of the user needing their backup.
:param timeframe the timeframe of the requested backup. Can be either
"weekly", or "monthly".
:param backup_date the backup-date of the requested backup. Must be in the
form YYYY-MM-DD.
"""
if flask.request.method != "GET":
return flask.abort(400)
# make sure the arguments are valid
if not re.match(r"^[a-z]+$", username) or \
not re.match(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}", backup_date) or \
timeframe not in ["weekly", "monthly"]:
app.logger.debug("backups(%s, %s, %s): invalid arguments"%(
username, timeframe, backup_date))
return flask.abort(400)
backups_base_dir = os.path.join(b.BACKUPS_DIR, username, timeframe)
return flask.send_from_directory(backups_base_dir, backup_date+".tgz")
def tutorials():
"""
Route: /tutorials
This route will render the tutorials page. Note that the markdown tutorial
files are read when the application starts-up.
"""
global TUTORIALS
if flask.request.method != "GET":
return flask.abort(400)
if len(TUTORIALS) == 0:
return flask.render_template("tutorials.html",
show_logout_button=l.is_logged_in(),
error="No tutorials to show")
if DEBUG:
TUTORIALS = []
populate_tutorials()
return flask.render_template("tutorials.html",
show_logout_button=l.is_logged_in(),
tutorials=TUTORIALS)
