def test_view_redirects_to_profile_url_after_getting_of_valid_form_data(
self, client, create_logged_in_user
):
form_data = {
"username": "******",
"email": "*****@*****.**",
"first_name": "test_first_name",
"last_name": "test_last_name",
}
response = client.post(
path=reverse("profile_change"),
data=form_data,
)
assert response.status_code == 302
assertRedirects(response, reverse("profile"))
redirect_url = response.url
next_response = client.get(redirect_url)
assert next_response.status_code == 200
assert next_response.context["user"].username == "new_test_username"
for message in next_response.context["messages"]:
if message.tags == "success":
assert (
message.message == "User's personal data has been changed."
)
def test_index(client, admin_client):
url = reverse('webapp.index')
resp = client.get(url)
assertRedirects(resp, reverse('webapp.login')+'?next='+url)
resp = admin_client.get(url)
assertTemplateUsed('index.html')
def test_post_import_switzerland_mobility_route_with_checkpoints(
athlete,
client,
switzerland_mobility_data_from_json,
mock_import_route_call_response,
):
route_json = "switzerland_mobility_route.json"
geom, _ = switzerland_mobility_data_from_json(route_json)
number_of_checkpoints = 5
route = SwitzerlandMobilityRouteFactory.build(
athlete=athlete, activity_type=ActivityTypeFactory(name="Run"))
ActivityFactory(athlete=athlete, activity_type=route.activity_type)
post_data = get_route_post_data(route)
post_data["checkpoints"] = create_checkpoints_from_geom(
geom, number_of_checkpoints)
post_response = mock_import_route_call_response(
data_source=route.data_source,
source_id=route.source_id,
api_response_json=route_json,
method="post",
post_data=post_data,
follow_redirect=True,
)
# a new route has been created with the post response
new_route = SwitzerlandMobilityRoute.objects.get(
data_source=route.data_source,
source_id=route.source_id,
athlete=athlete)
checkpoints = Checkpoint.objects.filter(route=new_route.pk)
assert checkpoints.count() == number_of_checkpoints
assertRedirects(post_response, new_route.get_absolute_url())
def test_view_redirects_to_profile_url_after_getting_of_valid_form_data(
self, client, create_logged_in_user
):
old_hash_password = User.objects.get(username="******").password
form_data = {
"old_password": "******",
"new_password1": "new_test_password",
"new_password2": "new_test_password",
}
response = client.post(
path=reverse("password_change"),
data=form_data,
)
assert response.status_code == 302
assertRedirects(response, reverse("profile"))
redirect_url = response.url
next_response = client.get(redirect_url)
assert next_response.status_code == 200
assert next_response.context["user"].password != old_hash_password
for message in next_response.context["messages"]:
if message.tags == "success":
assert message.message == "User password has been changed."
def test_project_views_unauthenticated_permissions(
client, project_url_names_to_fixtures, method, url_name):
"""Test unathorized requests cannot access project views"""
url = project_url_names_to_fixtures[url_name]
res = getattr(client, method)(url)
assertRedirects(res, reverse('members:login') + '?next=' + url)
def test_content_pages_links(client, parser, schedule, content_page_full_path):
"""Test to make sure all in-site links in a content page work.
"""
if '/surveys/conference/' in content_page_full_path:
pytest.skip("Skip for surveys/conference/ by purpose (or ask TP).")
body = parser.parse(client.get(content_page_full_path))
link_tags = body.cssselect('a[href^="/"]:not(a[href^="//"])')
link_status_codes = []
for tag in link_tags:
link = tag.get('href')
if "/events/schedule/" in link \
and settings.SCHEDULE_REDIRECT_URL:
assertRedirects(client.get(link),
settings.SCHEDULE_REDIRECT_URL,
fetch_redirect_response=False)
continue
try:
status = client.get(link, follow=True).status_code
except Exception: # Catch internal server error for better reporting.
status = 500
link_status_codes.append((link, status))
assert link_status_codes, 'isolated page: no links found'
def get_error_message():
errors = [
' {1} {0!r}'.format(*p) for p in link_status_codes
if p[1] != 200
]
if len(errors) == 1:
return errors[0].lstrip()
return 'Links do not return 200 status code\n' + '\n'.join(errors)
assert all(p[1] == 200 for p in link_status_codes), get_error_message()
def test_get_route_delete_not_logged(athlete, client):
route = RouteFactory(athlete=athlete)
url = route.get_absolute_url("delete")
client.logout()
response = client.get(url)
redirect_url = "/login/?next=" + url
assertRedirects(response, redirect_url)
def test_create_feed_login_required(client, feed):
url = reverse('feeds:update', args=(feed.pk,))
data = {
'name': 'Feed name',
}
response = client.post(url, data=data)
expected_redirect_url = f'{reverse("accounts:login")}?next={url}'
assertRedirects(response, expected_redirect_url)
def test_get_unauth(self, client: Client):
response = client.get("/gifting/create/", follow=True)
assertRedirects(
response,
"/users/login/?next=/gifting/create/",
status_code=302,
target_status_code=200,
)
def test_post_route_delete_view(athlete, client):
route = RouteFactory(athlete=athlete)
url = route.get_absolute_url("delete")
post_data = {}
response = client.post(url, post_data)
redirect_url = reverse("routes:routes")
assertRedirects(response, redirect_url)
def test_get_unauth(self, client: Client, ad: Ad):
response = client.get(f"/gifting/{ad.pk}/delete/", follow=True)
assertRedirects(
response,
f"/users/login/?next=/gifting/{ad.pk}/delete/",
status_code=302,
target_status_code=200,
)
def test_protected_page_not_logged_in(client: Client) -> None:
response = client.get(path=reverse("sample:protected"))
assertRedirects(
response,
expected_url=reverse("account_login") + "?next=%2Fprotected%2F",
status_code=HTTPStatus.FOUND,
target_status_code=HTTPStatus.OK,
)
def test_post_redirect_to_list_view(self, client):
correct_list = List.objects.create()
other_list = List.objects.create()
text = 'some random test'
response = client.post(f'/lists/{correct_list.id}/items/',
data={'new_item': text})
assertRedirects(response, f'/lists/{correct_list.id}/')
def test_get_strava_routes_connection_error(athlete, client):
error = "Could not connect to the remote server. Try again later:"
strava_routes_url = resolve_url("import_routes", data_source="strava")
response = client.get(strava_routes_url, follow=False)
redirected_response = client.get(strava_routes_url, follow=True)
assertRedirects(response, reverse("routes:routes"))
assertContains(redirected_response, error)
def test_post(self, user_client: Client, ad: Ad):
response = user_client.post(f"/gifting/{ad.pk}/delete/", follow=True)
assertRedirects(
response,
reverse("gifting:search"),
status_code=302,
target_status_code=200,
)
assert Ad.objects.all().exists() == False
def test_view_redirects_to_password_reset_done_url_after_getting_form_data(
self, client, create_activated_user
):
response = client.post(
path=reverse("password_reset"),
data={"email": "*****@*****.**"},
)
assert response.status_code == 302
assertRedirects(response, reverse("password_reset_done"))
def test_create_comment_login_required(client, feed_item):
url = reverse('feed_items:create_comment')
data = {
'feed_item': feed_item.pk,
'text': 'Comment text'
}
response = client.post(url, data=data)
expected_redirect_url = f'{reverse("accounts:login")}?next={url}'
assertRedirects(response, expected_redirect_url)
def test_get_garmin_upload(athlete, client, gpx_route):
upload_url = gpx_route.get_absolute_url("garmin_upload")
route_url = gpx_route.get_absolute_url()
with patch("homebytwo.routes.tasks.upload_route_to_garmin_task.delay"
) as mock_task:
response = client.get(upload_url)
assertRedirects(response, route_url)
assert mock_task.called
def test_upload_gpx_view(athlete, client, uploaded_file):
gpx_file = uploaded_file("grammont.gpx")
url = reverse("upload_gpx")
response = client.post(url, data={"gpx": gpx_file})
route = Route.objects.get(name="Grammont et Alamont")
redirect_url = reverse("routes:edit", kwargs={"pk": route.pk})
assert route.athlete == athlete
assertRedirects(response, redirect_url)
def test_POST_redirects_to_list_view(self, client):
other_list = List.objects.create()
correct_list = List.objects.create()
response = client.post(
f"/lists/{correct_list.id}/",
{"text": "A new item for existing list"},
)
test.assertRedirects(response, f"/lists/{correct_list.id}/")
def test_login(client, admin_client):
url = reverse('webapp.login')
resp = client.get(url)
assertTemplateUsed(resp, 'login.html')
resp = client.post(url, {'username': '******', 'password': '******'})
assertTemplateUsed(resp, 'login.html')
assert resp.context.get('failed') == True
resp = client.post(url, {'username': '******', 'password': '******'})
assertRedirects(resp, reverse('webapp.index'))
def test_member_views_unauthenticated_permissions(
client, member_url_names_to_fixtures, method, url_name, should_succed
):
"""Test unathorized requests cannot access member views"""
url = member_url_names_to_fixtures[url_name]
res = getattr(client, method)(url)
if should_succed:
assert res.status_code == 200
else:
assertRedirects(res, reverse('members:login') + '?next=' + url)
def test_codelistcreate_when_not_logged_in(client):
p = ProjectFactory()
csv_data = "code,description\n1067731000000107,Injury whilst swimming (disorder)"
data = {
"name": "Test Codelist",
"coding_system_id": "snomedct",
"description": "This is a test",
"methodology": "This is how we did it",
"csv_data": csv_builder(csv_data),
}
rsp = client.post(f"/codelist/{p.slug}/", data, follow=True)
assertRedirects(rsp, f"/accounts/login/?next=%2Fcodelist%2F{p.slug}%2F")
def test_redirect_when_strava_token_missing(athlete, client, mock_routes_response):
asocial_athlete = AthleteFactory(
user__password="******", user__social_auth=None
)
client.login(username=asocial_athlete.user.username, password="******")
routes_url = resolve_url("import_routes", data_source="strava")
response = client.get(routes_url)
login_url = "{url}?{params}".format(
url=reverse("login"), params=urlencode({"next": routes_url})
)
assertRedirects(response, login_url)
def test_get_import_switzerland_mobility_route_redirect_to_login_with_import_id(
athlete, client, mock_import_route_call_response):
source_id = 123456789
response = mock_import_route_call_response(
data_source="switzerland_mobility",
source_id=source_id,
api_response_json="403.json",
api_response_status=403,
)
params = urlencode({"import": source_id})
redirect_url = reverse("switzerland_mobility_login") + "?" + params
assertRedirects(response, redirect_url)
def test_post_route_edit_form(athlete, client):
route = RouteFactory(athlete=athlete, activity_type=ActivityTypeFactory())
ActivityFactory(athlete=athlete, activity_type=route.activity_type)
url = route.get_absolute_url("edit")
post_data = {
"name": route.name,
"activity_type": route.activity_type.id,
}
response = client.post(url, post_data)
redirect_url = route.get_absolute_url()
assertRedirects(response, redirect_url)
def test_get_update_switzerland_mobility_route_redirect_to_login_with_update_id(
athlete, client, mock_sm_route_response):
route = SwitzerlandMobilityRouteFactory(athlete=athlete)
url = route.get_absolute_url("update")
mock_sm_route_response(
source_id=route.source_id,
api_response_json="403.json",
api_response_status=403,
)
response = client.get(url)
params = urlencode({"update": route.pk})
redirect_url = reverse("switzerland_mobility_login") + "?" + params
assertRedirects(response, redirect_url)
def test_valid_redirect_user_logged_to_home_page(self, client, proto_user):
"""After login process, user should be redirect to home page."""
response = client.post(
reverse("login"),
{
"username": proto_user.username,
"password": "******",
"robot": True,
},
follow=True,
)
assert response.context["user"].is_authenticated
assertRedirects(response, "/")
def test_post_switzerland_mobility_login_update_id_bad(
athlete, client, mock_login_response, mock_sm_routes_response):
url = reverse("switzerland_mobility_login")
params = urlencode({"update": "bad_id"})
data = {"username": athlete.user.username, "password": "******"}
mock_login_response()
mock_sm_routes_response(athlete=athlete)
response = client.post(f"{url}?{params}", data)
mobility_cookies = client.session["switzerland_mobility_cookies"]
redirect_url = resolve_url("import_routes",
data_source="switzerland_mobility")
assertRedirects(response, redirect_url)
assert mobility_cookies["mf-chmobil"] == "123"
def test_checkin(client, admin_client):
url = reverse('webapp.checkin')
data = {'name': 'Someplace', 'lat': 100, 'lon': 200, 'address': '123'}
resp = admin_client.get(url, data)
user = User.objects.get(username='******')
l = Location.objects.get(user=user)
assert l.name == data['name']
assert l.address == data['address']
assert l.lat == float(data['lat'])
assert l.lon == float(data['lon'])
assertRedirects(resp, reverse('webapp.index'))
