def test_fetch_after_rerelease_gets_different_file(app, clear_database):
with patch.object(
BaseHandler, "get_current_user", return_value=user_kiz_instructor
):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(
BaseHandler, "get_current_user", return_value=user_brobbere_student
):
r = yield async_requests.get(
app.url + "/assignment?&course_id=course_2&assignment_id=assign_a"
)
r = yield async_requests.get(app.url + "/assignments?course_id=course_2")
with patch.object(
BaseHandler, "get_current_user", return_value=user_kiz_instructor
):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(
BaseHandler, "get_current_user", return_value=user_brobbere_student
):
r = yield async_requests.get(
app.url + "/assignment?&course_id=course_2&assignment_id=assign_a"
)
r = yield async_requests.get(app.url + "/assignments?course_id=course_2")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == True
assert "note" not in response_data # just that it's missing
paths = list(map(lambda assignment: assignment["path"], response_data["value"]))
actions = list(map(lambda assignment: assignment["status"], response_data["value"]))
assert len(paths) == 6
assert actions == [
"released",
"released",
"released",
"fetched",
"released",
"fetched",
]
assert paths[2] == paths[3] # First fetch = third release
assert paths[4] == paths[5] # Second fetch = fourth release
assert paths[3] != paths[5] # First fetch is not the same as the second fetch
def test_get_collection_with_a_blank_feedback_path_injected(
app, clear_database): # noqa: F811
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url + "/submission?course_id=course_2&assignment_id=assign_a",
files=files,
)
# Now manually inject a `feedback_fetched` action
import nbexchange.models.actions
from nbexchange.database import scoped_session
with scoped_session() as session:
action = nbexchange.models.actions.Action(
user_id=3,
assignment_id="assign_a",
action="feedback_fetched",
location=None,
)
session.add(action)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
collected_data = None
r = yield async_requests.get(
app.url + "/collections?course_id=course_2&assignment_id=assign_a"
) # Get the data we need to make test the call we want to make
response_data = r.json()
collected_data = response_data["value"][0]
r = yield async_requests.get(
app.url +
f"/collection?course_id={collected_data['course_id']}&path={collected_data['path']}&assignment_id={collected_data['assignment_id']}" # noqa: E501
)
assert r.status_code == 200
assert r.headers["Content-Type"] == "application/gzip"
assert int(r.headers["Content-Length"]) > 0
def test_fetch_fails_assignment_not_exists(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/assignment?course_id=course_2&assignment_id=assign_does_not_exist")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "Assignment assign_does_not_exist does not exist"
def test_post_location_different_each_time(app, clear_database):
with patch.object(
BaseHandler, "get_current_user", return_value=user_kiz_instructor
):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
r = yield async_requests.get(app.url + "/assignments?course_id=course_2")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == True
assert "note" not in response_data # just that it's missing
paths = list(map(lambda assignment: assignment["path"], response_data["value"]))
actions = list(map(lambda assignment: assignment["status"], response_data["value"]))
assert len(paths) == 3
assert paths[0] != paths[1] # 1st relase is not the same path as the 2nd release
assert paths[1] != paths[2] # 2nd not the same as 3rd
assert paths[0] != paths[2] # 1st not the same as third
assert actions == ["released", "released", "released"]
def test_post_submision_piks_first_instance_of_param_b(
app, clear_database): # noqa: F811
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url + "/submission?course_id=course_2&assignment_id=assign_a",
files=files,
)
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is True
assert response_data["note"] == "Submitted"
def test_post_submision_oversize_blocked(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "max_buffer_size", return_value=int(50)):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url +
"/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url +
"/assignment?course_id=course_2&assignment_id=assign_a")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url +
"/submission?course_id=course_2&assignment_id=assign_a",
files=files,
)
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert (
response_data["note"] ==
"File upload oversize, and rejected. Please reduce the files in your submission and try again."
)
def test_get_submission_501_even_authenticated(app):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url +
"/submission?course_id=course_2")
assert r.status_code == 501
def test_fetch_fails_user_not_subscribed(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/assignment?course_id=course_1&assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "User not subscribed to course course_1"
def test_fetch_fails_missing_course(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/assignment?assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "Assigment call requires both a course code and an assignment code!!"
def test_feedback_authenticated_no_params(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/feedback")
response_data = r.json()
assert response_data["success"] == False
assert (response_data["note"] ==
"Feedback call requires an assignment id and a course id")
def test_assignments1(self, app):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/assignments")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "Assigment call requires a course id"
def test_fetch_duplicate_param_first_is_right(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_brobbere_student):
r = yield async_requests.get(
app.url + "/assignment?course_id=course_2&course_id=cource_a&assignment_id=assign_does_not_exist"
)
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "Assignment assign_does_not_exist does not exist"
def test_assignments_broken_nbex_user(self, app, caplog):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz):
r = yield async_requests.get(app.url +
"/assignments?course_id=course_2")
assert r.status_code == 500
assert (
"Both current_course ('None') and current_role ('None') must have values. User was '1-kiz'"
in caplog.text)
def test_collections_fails_with_no_parameters(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/collections")
response_data = r.json()
assert response_data["success"] == False
assert (
response_data["note"] ==
"Collections call requires both a course code and an assignment code")
def test_get_collection_requires_parameters(app):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + "/collection")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data[
"note"] == "Collection call requires a course code, an assignment code, and a path"
def test_collections_students_cannot_collect(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url + "/collections?course_id=course_2&assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == False
assert response_data["note"] == "User not an instructor to course course_2"
def test_feedback_post_authenticated_with_correct_params_student_submitter(
app, clear_database):
assignment_id = "assign_a"
course_id = "course_2"
notebook = "notebook"
student = user_kiz_student
timestamp = datetime.datetime.utcnow().isoformat(" ")
checksum = notebook_hash(
feedback_filename,
make_unique_key(course_id, assignment_id, notebook, student["name"],
timestamp),
)
# XXX: Doing this in a separate function doesn't work for some reason (Exchange doesn't get called)
kwargs = {"data": {"notebooks": [notebook]}}
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url +
f"/assignment?course_id={course_id}&assignment_id={assignment_id}",
files=files,
**kwargs,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url +
f"/assignment?course_id={course_id}&assignment_id={assignment_id}")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url +
f"/submission?course_id={course_id}&assignment_id={assignment_id}",
files=files,
)
url = (f"/feedback?assignment_id={assignment_id}"
f"&course_id={course_id}"
f"¬ebook={notebook}"
f"&student={student['name']}"
f"×tamp={timestamp}"
f"&checksum={checksum}")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(app.url + url, files=feedbacks)
response_data = r.json()
assert response_data["success"] is False
assert response_data[
"note"] == f"User not an instructor to course {course_id}"
def test_assignments3(self, app):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url +
"/assignments?course_id=course_2")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is True
assert "note" not in response_data # just that it's missing
assert "value" in response_data # just that it's present (it will have no content)
def test_assignments2(self, app):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url +
"/assignments?course_id=course_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data[
"note"] == "User not subscribed to course course_a"
def test_student_can_fetch(app, clear_database): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler, "get_current_user", return_value=user_brobbere_student):
r = yield async_requests.get(app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
assert r.status_code == 200
assert r.headers["Content-Type"] == "application/gzip"
assert int(r.headers["Content-Length"]) > 0
def test_collections_repeated_parameters_wrong_first(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_brobbere_instructor):
r = yield async_requests.get(
app.url +
"/collections?course_id=course_1&course_2&assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == False
assert response_data["note"] == "User not subscribed to course course_1"
def test_fetch_broken_nbex_user(app, clear_database, caplog): # noqa: F811
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler, "get_current_user", return_value=user_kiz):
r = yield async_requests.get(app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
assert r.status_code == 500
assert (
"Both current_course ('None') and current_role ('None') must have values. User was '1-kiz'" in caplog.text
)
def test_feedback_authenticated_with_params(app, clear_database):
assignment_id = "my_assignment"
course_id = "my_course"
url = f"/feedback?assignment_id={assignment_id}&course_id={course_id}"
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url + url)
assert r.status_code == 404
def test_delete_student_blocked(app, clear_database): # noqa: F811
with patch.object(BaseHandler,
"get_current_user",
return_value=user_zik_student):
r = yield async_requests.get(app.url +
"/assignments?course_id=course_2")
r = yield async_requests.delete(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data["note"] == "User not an instructor to course course_2"
def test_collections_with_two_users_submitting(app,
clear_database): # noqa: F811
assignment_id_1 = "assign_a"
assignment_id_2 = "b_assign"
course_id = "course_2"
notebook = "notebook"
# XXX: Doing this in a separate function doesn't work for some reason
# (Exchange doesn't get called)
kwargs = {"data": {"notebooks": [notebook]}}
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url +
f"/assignment?course_id={course_id}&assignment_id={assignment_id_1}",
files=files,
**kwargs,
) # Release
r = yield async_requests.post(
app.url +
f"/assignment?course_id={course_id}&assignment_id={assignment_id_2}",
files=files,
**kwargs,
) # Release 2nd assignment
# Submissions check for a released action, not a fetched one
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url +
f"/submission?course_id={course_id}&assignment_id={assignment_id_1}",
files=files,
) # submit
with patch.object(BaseHandler,
"get_current_user",
return_value=user_brobbere_student):
r = yield async_requests.post(
app.url +
f"/submission?course_id={course_id}&assignment_id={assignment_id_1}",
files=files,
) # submit 2nd user
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(
app.url +
f"/collections?course_id={course_id}&assignment_id={assignment_id_1}"
) # collect
response_data = r.json()
assert response_data["success"] is True
assert len(response_data["value"]) == 2
def test_collections_zero_results_instructor_autosubscribed_to_course(
app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_brobbere_instructor):
r = yield async_requests.get(
app.url + "/collections?course_id=course_2&assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == True
assert "note" not in response_data # just that it's missing
assert response_data["value"] == []
def test_fetch_duplicate_param_first_is_wrong(app, clear_database):
with patch.object(
BaseHandler, "get_current_user", return_value=user_brobbere_student
):
r = yield async_requests.get(
app.url
+ "/assignment?course_id=course_a&course_id=cource_2&assignment_id=assign_a"
)
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == False
assert response_data["note"] == "User not subscribed to course course_a"
def test_collections_fails_with_just_assignment_parameter(
app, clear_database): # noqa: F811
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(app.url +
"/collections?assignment_id=assign_a")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] is False
assert response_data[
"note"] == "Collections call requires both a course code and an assignment code"
def test_get_collection_catches_missing_path(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.post(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.get(
app.url + "/assignment?course_id=course_2&assignment_id=assign_a")
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_student):
r = yield async_requests.post(
app.url + "/submission?course_id=course_2&assignment_id=assign_a",
files=files,
)
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
collected_data = None
r = yield async_requests.get(
app.url + "/collections?course_id=course_2&assignment_id=assign_a"
) ## Get the data we need to make test the call we want to make
response_data = r.json()
collected_data = response_data["value"][0]
r = yield async_requests.get(
app.url +
f"/collection?course_id={collected_data['course_id']}&assignment_id={collected_data['assignment_id']}"
)
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == False
assert (
response_data["note"] ==
"Collection call requires a course code, an assignment code, and a path"
)
def test_collections_zero_results_with_wrong_course(app, clear_database):
with patch.object(BaseHandler,
"get_current_user",
return_value=user_kiz_instructor):
r = yield async_requests.get(
app.url +
"/collections?course_id=course_2&assignment_id=assign_b2")
assert r.status_code == 200
response_data = r.json()
assert response_data["success"] == True
assert "note" not in response_data # just that it's missing
assert response_data["value"] == [] # it will have no content
