def test_the_code_from_auth_can_be_exchanged(self, app, user, params):
self.login(app, user)
response = app.get("/oauth/authorize", params=params, status=200)
js_settings = self._approve_authorize_request(response)
code = js_settings["code"]
response = app.post(
"/api/token",
params={
"client_id": params["client_id"],
"code": code,
"grant_type": GrantType.authorization_code.value,
},
status=200,
)
assert response.headers["Content-Type"] == Any.string.matching(
"application/json"
)
assert response.json == Any.dict.containing(
{
"token_type": "Bearer",
"access_token": Any.string(),
"refresh_token": Any.string(),
}
)
def test_calls_renderers_with_appropriate_context(self, pyramid_request,
html_renderer,
text_renderer):
generate(pyramid_request, "*****@*****.**")
expected_context = {
"time": Any.string(),
"hostname": Any.string(),
"python_version": Any.string(),
"version": __version__,
}
html_renderer.assert_(**expected_context)
text_renderer.assert_(**expected_context)
def test_it(self, newrelic, search_index):
indexer.report_sync_annotations_queue_length()
search_index._queue.count.assert_called_once_with(
["storage.create_annotation", "storage.update_annotation"])
newrelic.agent.record_custom_metric.assert_called_once_with(
Any.string(), search_index._queue.count.return_value)
def test_it_can_apply_a_matcher_to_all_elements(self):
matcher = HostClass.comprised_of(Any.string())
assert matcher == ["a", "b"]
assert matcher == {"a": 1, "b": 2}
assert matcher != ["a", "b", 1]
assert matcher != {"a": 1, "b": 1, 3: None}
def test_it_extracts_config(self, call_view_pdf, Configuration):
response = call_view_pdf()
Configuration.extract_from_params.assert_called_once_with(
Any.mapping.containing({"url": Any.string()})
)
assert response["hypothesis_config"] == sentinel.h_config
def test_it_works_with_good_params(self, pyramid_request):
pyramid_request.params[
"launch_presentation_return_url"] = "http://example.com"
schema = BasicLTILaunchSchema(pyramid_request)
params = schema.parse()
assert params == Any.dict.containing(
{"resource_link_id": Any.string()})
def test_it_logs_when_an_error_is_filtered(self, caplog):
caplog.set_level(logging.INFO)
get_before_send([self.always_filter])(sentinel.event_dict,
sentinel.hint_dict)
assert caplog.record_tuples == [
(Any.string(), logging.INFO,
Any.string.containing(LOG_MESSAGE_PREFIX))
]
def test_get_static_content(self, url, mime_type, test_app):
response = test_app.get(url)
assert dict(response.headers) == Any.dict.containing({
"Content-Type":
Any.string.containing(mime_type),
"ETag":
Any.string()
})
assert_cache_control(response.headers, ["public", "max-age=60"])
def test_authorisation_presents_form_if_logged_in(self, app, user, params):
self.login(app, user)
response = app.get("/oauth/authorize", params=params, status=200)
js_settings = self._approve_authorize_request(response)
assert js_settings == {
"code": Any.string(),
"origin": "http://localhost:5000",
"state": params["state"],
}
def test_creation(self, json_schema_error, JSONAPIErrorBody):
error = SchemaValidationError([json_schema_error])
assert error.error_bodies == [JSONAPIErrorBody.create.return_value]
JSONAPIErrorBody.create.assert_called_once_with(
error,
detail=Any.string(),
meta={"schema": {"pointer": "properties/a/type"}, "context": []},
pointer="a",
status=400,
)
def test_it_adds_timeout_options_for_failfast(self, Connection):
realtime.get_connection({}, fail_fast=True)
Connection.assert_called_once_with(
Any.string(),
transport_options={
"max_retries": Any.int(),
"interval_start": Any(),
"interval_step": Any(),
"interval_max": Any(),
},
)
def test_iter_file(self, api, AuthorizedSession):
# This is all a bit black box, we don't necessarily know what all these
# Google objects do, so we'll just check we call them in the right way
list(api.iter_file("FILE_ID"))
# pylint: disable=no-member,protected-access
AuthorizedSession.return_value.request.assert_called_once_with(
"GET",
"https://www.googleapis.com/drive/v3/files/FILE_ID?alt=media",
headers={
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"User-Agent": "(gzip)",
# This is looked up from the resource mapping
"X-Goog-Drive-Resource-Keys": "FILE_ID/RESOURCE_ID",
# Quick check to show we use `add_request_headers`
"X-Abuse-Policy": Any.string(),
"X-Complaints-To": Any.string(),
},
stream=True,
timeout=GoogleDriveAPI.TIMEOUT,
max_allowed_time=GoogleDriveAPI.TIMEOUT,
)
def test_proxy_pdf(self, test_app):
target_url = "http://example.com"
response = test_app.get(f"/route?url={target_url}")
assert response.status_code == 302
query = dict(self.DEFAULT_OPTIONS)
query["via.sec"] = Any.string()
query["url"] = target_url
assert response.location == Any.url.matching(
f"http://localhost/pdf?url={quote_plus(target_url)}").with_query(
query)
assert_cache_control(
response.headers,
["public", "max-age=300", "stale-while-revalidate=86400"])
def test_it(self, pyramid_request, user):
pyramid_request.matched_route = None
pyramid_request.params["q"] = "tag:question"
pyramid_request.user = user
result = navbar_data(pyramid_request)
assert result == {
"create_group_item": {
"link": "http://example.com/groups/new",
"title": "Create new group",
},
"groups_menu_items": [
{
"title": group.name,
"link": f"http://example.com/groups/{group.pubid}/{group.slug}",
}
for group in user.groups
],
"groups_suggestions": [
{
"name": group.name,
"pubid": group.pubid,
"relationship": "Creator" if group.creator == user else None,
}
for group in user.groups
],
"q": "tag:question",
"search_url": Any.string(),
"settings_menu_items": [
{"link": "http://example.com/account", "title": "Account details"},
{"link": "http://example.com/account/profile", "title": "Edit profile"},
{
"link": "http://example.com/account/notifications",
"title": "Notifications",
},
{"link": "http://example.com/account/developer", "title": "Developer"},
],
"signout_item": {"link": "http://example.com/logout", "title": "Sign out"},
"username": user.username,
"username_url": f"http://example.com/users/{user.username}",
}
def test_it_sets_expected_fields(self, pyramid_request, parsed_params,
url_params):
parsed_params["h_username"] = "******"
parsed_params["learner_canvas_user_id"] = "learner_canvas_user_id"
pyramid_request.parsed_params = parsed_params
result = CanvasPreRecordHook(pyramid_request)(score=None,
request_body={
"resultRecord": {}
})
assert result == {
"resultRecord": {
"result": {
"resultData": {
"ltiLaunchUrl": Any.string()
}
}
},
"submissionDetails": {
"submittedAt": datetime.datetime(2001,
1,
1,
tzinfo=timezone.utc)
},
}
launch_url = result["resultRecord"]["result"]["resultData"][
"ltiLaunchUrl"]
assert launch_url.startswith("http://example.com/lti_launches?")
query_string = parse_qs(urlparse(launch_url).query)
assert query_string == dict(
url_params,
focused_user=["h_username"],
learner_canvas_user_id=["learner_canvas_user_id"],
)
def test_deleted_still_returns_read_permissions(self, get_context_acl,
factories):
acl = get_context_acl(factories.Annotation(deleted=True))
assert acl[0] == ("Allow", Any.string(), "read")
def test_it_adds_timeout_options_for_failfast(self, Connection):
realtime.get_connection({}, fail_fast=True)
Connection.assert_called_once_with(
Any.string(), transport_options=RETRY_POLICY_QUICK)
def assert_cache_control(headers, cache_parts):
"""Assert that all parts of the Cache-Control header are present."""
assert dict(headers) == Any.dict.containing(
{"Cache-Control": Any.string()})
assert (headers["Cache-Control"].split(", ") == Any.list.containing(
cache_parts).only())