def test_deploy_ramp_event(session_scope_function): database_config = read_config(database_config_template()) event_config_filename = ramp_config_template() event_config = read_config(event_config_filename) ramp_config = generate_ramp_config(event_config) deploy_ramp_event(database_config_template(), ramp_config_template()) # simulate that we add users and sign-up for the event and that they # submitted the starting kit with session_scope(database_config['sqlalchemy']) as session: add_users(session) sign_up_team(session, ramp_config['event_name'], 'test_user') submit_starting_kits(session, ramp_config['event_name'], 'test_user', ramp_config['ramp_kit_submissions_dir']) # run the dispatcher on the event which are in the dataset dispatcher = Dispatcher(config=database_config, event_config=event_config, worker=CondaEnvWorker, n_workers=-1, hunger_policy='exit') dispatcher.launch() # the iris kit contain a submission which should fail for a user with session_scope(database_config['sqlalchemy']) as session: submission = get_submissions(session, event_config['ramp']['event_name'], 'training_error') assert len(submission) == 1
def test_user_event_status(client_session): client, session = client_session add_user(session, 'new_user', 'new_user', 'new_user', 'new_user', 'new_user', access_level='user') add_event(session, 'iris', 'iris_new_event', 'new_event', 'starting_kit', '/tmp/databoard_test/submissions', is_public=True) # user signed up, not approved for the event ask_sign_up_team(session, 'iris_new_event', 'new_user') with login_scope(client, 'new_user', 'new_user') as client: rv = client.get('/problems') assert rv.status_code == 200 assert b'user-waiting' in rv.data assert b'user-signed' not in rv.data # user signed up and approved for the event sign_up_team(session, 'iris_new_event', 'new_user') with login_scope(client, 'new_user', 'new_user') as client: rv = client.get('/problems') assert rv.status_code == 200 assert b'user-signed' in rv.data assert b'user-waiting' not in rv.data
def test_sign_up_team(session_scope_function): event_name, username = '******', 'test_user' sign_up_team(session_scope_function, event_name, username) event_team = session_scope_function.query(EventTeam).all() assert len(event_team) == 1 event_team = event_team[0] # when signing up a team, the team is approved and the sandbox is setup: # the starting kit is submitted without training it. assert event_team.last_submission_name == 'starting_kit' assert event_team.approved is True # check the status of the sandbox submission submission = session_scope_function.query(Submission).all() assert len(submission) == 1 submission = submission[0] assert submission.name == 'starting_kit' assert submission.event_team == event_team submission_file = submission.files[0] assert submission_file.name == 'classifier' assert submission_file.extension == 'py' assert (os.path.join('submission_000000001', 'classifier.py') in submission_file.path) # check the submission on cv fold cv_folds = session_scope_function.query(SubmissionOnCVFold).all() for fold in cv_folds: assert fold.state == 'new' assert fold.best is False assert fold.contributivity == pytest.approx(0)
def approve_sign_up_for_event(event_name, user_name): """Approve a user for a specific event. This way of approval is usually used by clicking in an email sent to the admin. Parameters ---------- event_name : str The name of the event. user_name : str The name of the user. """ event = get_event(db.session, event_name) user = User.query.filter_by(name=user_name).one_or_none() if not is_admin(db.session, event_name, flask_login.current_user.name): return redirect_to_user( u'Sorry {}, you do not have admin rights'.format( flask_login.current_user.firstname), is_error=True) if not event or not user: return redirect_to_user(u'No event {} or no user {}'.format( event_name, user_name), is_error=True) sign_up_team(db.session, event.name, user.name) subject = ('Signed up for the RAMP event {}'.format(event.name)) body = ('{}, you have been registered to the RAMP event {}. ' 'You can now proceed to your sandbox and make submission.' '\nHave fun!!!'.format(flask_login.current_user.name, event.name)) send_mail(to=flask_login.current_user.email, subject=subject, body=body) return redirect_to_user(u'{} is signed up for {}.'.format(user, event), is_error=False, category='Successful sign-up')
def approve_users(): """Approve new user to log-in and sign-up to events.""" if not flask_login.current_user.access_level == 'admin': return redirect_to_user( 'Sorry {}, you do not have admin rights'.format( flask_login.current_user.firstname), is_error=True) if request.method == 'GET': # TODO: replace by some get_functions asked_users = User.query.filter_by(access_level='asked').all() asked_sign_up = EventTeam.query.filter_by(approved=False).all() return render_template('approve.html', asked_users=asked_users, asked_sign_up=asked_sign_up, admin=True) elif request.method == 'POST': users_to_be_approved = request.form.getlist('approve_users') event_teams_to_be_approved = request.form.getlist( 'approve_event_teams') message = "{}d users:\n".format(request.form["submit_button"][:-1]) for asked_user in users_to_be_approved: user = select_user_by_name(db.session, asked_user) if request.form["submit_button"] == "Approve!": approve_user(db.session, asked_user) subject = 'Your RAMP account has been approved' body = ('{}, your account has been approved. You can now ' 'sign-up for any open RAMP event.'.format(user.name)) send_mail(to=user.email, subject=subject, body=body) elif request.form["submit_button"] == "Remove!": delete_user(db.session, asked_user) message += "{}\n".format(asked_user) message += "{}d event_team:\n".format( request.form["submit_button"][:-1]) for asked_id in event_teams_to_be_approved: asked_event_team = EventTeam.query.get(asked_id) user = select_user_by_name(db.session, asked_event_team.team.name) if request.form["submit_button"] == "Approve!": sign_up_team(db.session, asked_event_team.event.name, asked_event_team.team.name) subject = ('Signed up for the RAMP event {}'.format( asked_event_team.event.name)) body = ('{}, you have been registered to the RAMP event {}. ' 'You can now proceed to your sandbox and make ' 'submissions.\nHave fun!!!'.format( user.name, asked_event_team.event.name)) send_mail(to=user.email, subject=subject, body=body) elif request.form["submit_button"] == "Remove!": delete_event_team(db.session, asked_event_team.event.name, asked_event_team.team.name) message += "{}\n".format(asked_event_team) return redirect_to_user(message, is_error=False, category="{}d users".format( request.form["submit_button"][:-1]))
def test_sandbox_upload_file(client_session, makedrop_event, submission_dir, filename): client, session = client_session sign_up_team(session, "iris_test_4event", "test_user") config = ramp_config_template() ramp_config = generate_ramp_config(read_config(config)) # upload file in sandbox.html path_submissions = os.path.join(ramp_config["ramp_kit_dir"], submission_dir) with login_scope(client, "test_user", "test") as client: rv = client.get("http://localhost/events/iris_test_4event/sandbox") assert rv.status_code == 200 # choose file and check if it was uploaded correctly path_submission = os.path.join(path_submissions, filename) assert os.path.isfile(path_submission) rv = client.post( "http://localhost/events/iris_test_4event/sandbox", headers={ "Referer": "http://localhost/events/iris_test_4event/sandbox" }, data={"file": (open(path_submission, "rb"), filename)}, follow_redirects=False, ) assert rv.status_code == 302 assert ( rv.location == "http://localhost/events/iris_test_4event/sandbox") # code of the saved file with open(path_submission, "r") as file: submitted_data = file.read() # code from the db event = get_event(session, "iris_test_4event") sandbox_submission = get_submission_by_name(session, "iris_test_4event", "test_user", event.ramp_sandbox_name) submission_code = sandbox_submission.files[-1].get_code() # get user interactions from db and check if 'upload' was added user_interactions = get_user_interactions_by_name(session, "test_user") # check if the code of the submitted file in the 'submission_code' assert submitted_data is not None assert submitted_data in submission_code # check if the user_interaction was added to the db assert "upload" in user_interactions["interaction"].values
def test_delete_event_team(session_scope_function): event_name, username = '******', 'test_user' sign_up_team(session_scope_function, event_name, username) event_team = session_scope_function.query(EventTeam).all() assert len(event_team) == 1 delete_event_team(session_scope_function, event_name, username) event_team = session_scope_function.query(EventTeam).all() assert len(event_team) == 0 # check that the user still exist user = (session_scope_function.query(User).filter( User.name == username).all()) assert len(user) == 1 event = (session_scope_function.query(Event).filter( Event.name == event_name).all()) assert len(event) == 1
def test_sandbox_save_file(client_session, makedrop_event): client, session = client_session sign_up_team(session, "iris_test_4event", "test_user") example_code = "example content" with login_scope(client, "test_user", "test") as client: rv = client.get("http://localhost/events/iris_test_4event/sandbox") assert rv.status_code == 200 rv = client.post( "http://localhost/events/iris_test_4event/sandbox", headers={ "Referer": "http://localhost/events/iris_test_4event/sandbox" }, data={ "estimator": example_code, "code-csrf_token": "temp_token" }, follow_redirects=False, ) assert rv.status_code == 200 # code from the db event = get_event(session, "iris_test_4event") sandbox_submission = get_submission_by_name(session, "iris_test_4event", "test_user", event.ramp_sandbox_name) submission_code = sandbox_submission.files[-1].get_code() # get user interactions from db and check if 'save' was added user_interactions = get_user_interactions_by_name(session, "test_user") assert "save" in user_interactions["interaction"].values assert example_code in submission_code # make sure that after changing the code example # and reloading the page the code is still changed with login_scope(client, "test_user", "test") as client: rv = client.get("http://localhost/events/iris_test_4event/sandbox") assert rv.status_code == 200 assert example_code.encode() in rv.data
def sign_up_for_event(event_name): """Landing page to sign-up to a specific RAMP event. Parameters ---------- event_name : str The name of the event. """ event = get_event(db.session, event_name) if not is_accessible_event(db.session, event_name, flask_login.current_user.name): return redirect_to_user('{}: no event named "{}"' .format(flask_login.current_user.firstname, event_name)) if app.config['TRACK_USER_INTERACTION']: add_user_interaction(db.session, interaction='signing up at event', user=flask_login.current_user, event=event) ask_sign_up_team(db.session, event.name, flask_login.current_user.name) if event.is_controled_signup: admin_users = User.query.filter_by(access_level='admin') for admin in admin_users: subject = ('Request to sign-up {} to RAMP event {}' .format(event.name, flask_login.current_user.name)) body = body_formatter_user(flask_login.current_user) url_approve = ('http://{}/events/{}/sign_up/{}' .format( app.config['DOMAIN_NAME'], event.name, flask_login.current_user.name )) body += ('Click on this link to approve the sign-up request: {}' .format(url_approve)) send_mail(admin, subject, body) return redirect_to_user("Sign-up request is sent to event admins.", is_error=False, category='Request sent') sign_up_team(db.session, event.name, flask_login.current_user.name) return redirect_to_sandbox( event, '{} is signed up for {}.' .format(flask_login.current_user.firstname, event), is_error=False, category='Successful sign-up' )
def test_submit_button_enabled_disabled(client_session, makedrop_event, opening_date, public_date, closing_date, expected): client, session = client_session event = get_event(session, 'iris_test_4event') event.opening_timestamp = opening_date event.public_opening_timestamp = public_date event.closing_timestamp = closing_date session.commit() sign_up_team(session, 'iris_test_4event', 'test_user') with login_scope(client, 'test_user', 'test') as client: rv = client.get('http://localhost/events/iris_test_4event/sandbox') assert rv.status_code == 200 # check for update button status on the generated .html if expected == b'event-close': assert 'disabled' in str(rv.data) # should to be disabled else: assert 'disabled' not in str(rv.data) # should not be disabled
def test_correct_message_sandbox(client_session, makedrop_event, opening_date, public_date, closing_date, expected): client, session = client_session event = get_event(session, 'iris_test_4event') event.opening_timestamp = opening_date event.public_opening_timestamp = public_date event.closing_timestamp = closing_date session.commit() sign_up_team(session, 'iris_test_4event', 'test_user') with login_scope(client, 'test_user', 'test') as client: rv = client.get('http://localhost/events/iris_test_4event/sandbox') assert rv.status_code == 200 if NOW < opening_date: assert "Event submissions will open on the " in str(rv.data) elif NOW < closing_date: assert "Event submissions are open until " in str(rv.data) else: assert "This event closed on the " in str(rv.data)
def test_sandbox_upload_file_dont_exist(client_session, makedrop_event, submission_dir, filename): client, session = client_session sign_up_team(session, "iris_test_4event", "test_user") config = ramp_config_template() ramp_config = generate_ramp_config(read_config(config)) # upload file in sandbox.html path_submissions = os.path.join(ramp_config["ramp_kit_dir"], ) with login_scope(client, "test_user", "test") as client: rv = client.get("http://localhost/events/iris_test_4event/sandbox") assert rv.status_code == 200 # choose file and check if it was uploaded correctly path_submission = os.path.join(path_submissions, filename) assert not os.path.isfile(path_submission) with pytest.raises(FileNotFoundError): rv = client.post( "http://localhost/events/iris_test_4event/sandbox", headers={ "Referer": "http://localhost/events/iris_test_4event/sandbox" }, data={"file": (open(path_submission, "rb"), filename)}, follow_redirects=False, ) assert rv.status_code == 200 with pytest.raises(FileNotFoundError): with open(path_submission, "r") as file: submitted_data = file.read() assert not submitted_data # get user interactions from db and check if 'upload' was added user_interactions = get_user_interactions_by_name(session, "test_user") assert "upload" not in user_interactions["interaction"].values
def test_is_accessible_code(session_toy_db): # create a third user add_user( session_toy_db, name='test_user_3', password='******', lastname='Test_3', firstname='User_3', email='*****@*****.**', access_level='user') approve_user(session_toy_db, 'test_user_3') event_name = 'iris_test' sign_up_team(session_toy_db, event_name, 'test_user_3') # simulate a user which is not authenticated user = get_user_by_name(session_toy_db, 'test_user_2') user.is_authenticated = False assert not is_accessible_code(session_toy_db, event_name, user.name) # simulate a user which authenticated and author of the submission to a # public event user.is_authenticated = True assert is_accessible_code(session_toy_db, event_name, user.name) # simulate an admin user user = get_user_by_name(session_toy_db, 'test_iris_admin') user.is_authenticated = True assert is_accessible_code(session_toy_db, event_name, 'test_iris_admin') # simulate a user which is not signed up to the event user = add_user(session_toy_db, 'xx', 'xx', 'xx', 'xx', 'xx', 'user') user.is_authenticated = True assert not is_accessible_code(session_toy_db, event_name, user.name) # simulate that the event is not publicly opened event = get_event(session_toy_db, event_name) past_public_opening = event.public_opening_timestamp tomorrow = datetime.datetime.utcnow() + datetime.timedelta(days=1) event.public_opening_timestamp = tomorrow session_toy_db.commit() assert is_accessible_code(session_toy_db, event_name, 'test_user_3') # Make a submission submission_name = 'random_forest_10_10' ramp_config = generate_ramp_config(read_config(ramp_config_template())) path_submission = os.path.join( os.path.dirname(ramp_config['ramp_sandbox_dir']), submission_name ) sub = add_submission( session_toy_db, event_name, 'test_user_3', submission_name, path_submission ) # check that the user submitting the submission could access it assert is_accessible_code( session_toy_db, event_name, 'test_user_3', sub.id ) # change the admin of the team from ramp_database.model import Team, User team = (session_toy_db.query(Team) .filter(Team.name == 'test_user_3') .first()) user = (session_toy_db.query(User) .filter(User.name == 'test_user_2') .first()) team.admin_id = user.id team.admin = user session_toy_db.commit() # check that the admin can access the submission assert is_accessible_code( session_toy_db, event_name, 'test_user_2', sub.id ) # but others cannot assert not is_accessible_code( session_toy_db, event_name, 'test_user_3', sub.id ) event.public_opening_timestamp = past_public_opening session_toy_db.commit()