def test_create_trip_bad_request(call_create_trip_endpoint):
get_or_create_user(external_id="foo")
assert 0 == count_trips_in_db()
response = call_create_trip_endpoint(data={"title": 0})
assert response.status_code == 400
assert 0 == count_trips_in_db()
def test_update_trip_member_of():
trip_owner, _ = get_or_create_user("foo")
trip_member, _ = get_or_create_user("bar")
trip = create_trip(trip_owner, title="trip 1")
add_member_to_trip(trip_member, trip)
update_trip(trip_member, trip, title="another name")
trip.refresh_from_db()
assert trip.title == "another name"
def test_update_other_users_trip():
user, _ = get_or_create_user("foo")
someone_else, _ = get_or_create_user("bar")
trip = create_trip(user, title="unspoilt")
with pytest.raises(PermissionError):
update_trip(someone_else, trip, title="mwahaha")
trip.refresh_from_db()
assert trip.title == "unspoilt"
def test_get_members_of_trip(trip_owner, trip):
member_1, _ = get_or_create_user("member-1")
member_2, _ = get_or_create_user("member-2")
member_3, _ = get_or_create_user("member-of-another-trip")
other_trip = create_trip(trip_owner, "other-trip")
add_member_to_trip(member_3, other_trip)
add_member_to_trip(member_1, trip)
add_member_to_trip(member_2, trip)
members_of_trip = [member.user for member in get_members_of_trip(trip)]
assert 3 == len(members_of_trip)
assert {trip_owner, member_1, member_2} == set(members_of_trip)
def test_update_trip():
user, _ = get_or_create_user("foo")
original_trip = create_trip(user,
title="bad title",
description="bad desc",
tags=["a", "b"])
update_1 = update_trip(
user,
original_trip,
title="good title",
description="good desc",
tags=["1", "2"],
)
assert original_trip.pk == update_1.pk
assert update_1.title == "good title"
assert update_1.description == "good desc"
assert update_1.tags == ["1", "2"]
update_2 = update_trip(user,
update_1,
description="even better desc",
tags=[])
assert original_trip.pk == update_2.pk
assert update_2.title == "good title"
assert update_2.description == "even better desc"
assert update_2.tags == []
assert 1 == len(Trip.objects.all())
def test_get_trip_by_id(django_assert_num_queries):
trip_owner, _ = get_or_create_user("trip-owner")
trip = create_trip(trip_owner, "test trip")
trip_member, _ = get_or_create_user("trip-member")
add_member_to_trip(trip_member, trip)
for user in [trip_owner, trip_member]:
with django_assert_num_queries(1):
retrieved_trip = get_trip_by_id(user, trip.trip_id)
assert retrieved_trip.pk == trip.pk
assert get_trip_by_id(trip_owner, str(uuid4())) is None
someone_else, _ = get_or_create_user("someone-else")
assert get_trip_by_id(someone_else, uuid4()) is None
def wrapper(request, *args, **kwargs):
if settings.IS_TEST_ENVIRONMENT:
user = get_user_from_test_user_header(request.META)
if user is not None:
request.user = user
return func(request, *args, **kwargs)
auth_header = get_authorization_header(request.META)
if auth_header is None:
return error_response(status=401,
message="Missing authorization header")
token = get_token_from_authorization_header(auth_header)
try:
claims = decode(token,
public_key,
algorithms="RS256",
audience=AUDIENCE_NAME)
user, created = get_or_create_user(claims["sub"])
except (InvalidTokenError, KeyError) as e:
logger.info("Failed to decode authorization token: %s", e)
return error_response(status=401,
message="Invalid authorization token")
if created:
logger.info(
"First time user with external_id '%s' has authenticated",
claims["sub"],
)
request.user = user
return func(request, *args, **kwargs)
def test_update_unowned_trip(call_endpoint, trip):
someone_else, _ = get_or_create_user("bar")
response = call_endpoint(someone_else,
trip.trip_id,
data={"title": "mwahaha"})
assert 404 == response.status_code
assert Trip.objects.get(pk=trip.pk).title != "mwahaha"
def test_get_move_by_move_id(user, location_1, location_2):
db_move = create_move(location_1, location_2)
retrieved_move = get_move_by_move_id(user, db_move.move_id)
assert retrieved_move.pk == db_move.pk
someone_else, _ = get_or_create_user("someone-else")
assert get_move_by_move_id(someone_else, db_move.move_id) is None
def test_add_duplicate_member_to_trip(trip):
somebody, _ = get_or_create_user("test-user")
add_member_to_trip(somebody, trip)
with pytest.raises(UserIsAlreadyMember):
add_member_to_trip(somebody, trip)
object_in_db = TripMember.objects.get(user=somebody, trip=trip)
assert object_in_db.is_admin is False
def test_get_trips_for_user(time, django_assert_num_queries):
one_h_ago = time - timedelta(hours=1)
two_h_ago = time - timedelta(hours=2)
user_1, _ = get_or_create_user("user-1")
user_2, _ = get_or_create_user("user-2")
trip_1 = create_trip_at_time(user_1, one_h_ago, title="trip-1")
trip_2 = create_trip_at_time(user_2, two_h_ago, title="trip-2")
create_trip_at_time(user_2, two_h_ago, title="trip-3", is_deleted=True)
add_member_to_trip(user_1, trip_2)
with django_assert_num_queries(1):
get_trips_for_user(user_1)
assert [trip_1, trip_2] == get_trips_for_user(user_1, ascending=False)
assert [trip_2, trip_1] == get_trips_for_user(user_1, ascending=True)
assert [trip_2] == get_trips_for_user(user_2)
def test_add_member_to_trip(trip):
somebody, _ = get_or_create_user("test-user")
assert 1 == len(TripMember.objects.all())
add_member_to_trip(somebody, trip, is_admin=False)
assert 2 == len(TripMember.objects.all())
object_in_db = TripMember.objects.get(user=somebody, trip=trip)
assert object_in_db.user == somebody
assert object_in_db.trip == trip
assert object_in_db.is_admin is False
def test_create_trip(call_create_trip_endpoint, data):
get_or_create_user(external_id="foo")
assert 0 == count_trips_in_db()
response = call_create_trip_endpoint(data=data)
assert response.status_code == 201
assert 1 == count_trips_in_db()
response_json = safe_parse_json(response.content)
expected_response_data = {
"trip_id": response_json.get("trip_id"),
"created_on": response_json.get("created_on"),
"title": data["title"],
}
if data.get("description", "") != "":
expected_response_data["description"] = data["description"]
if "tags" in data:
expected_response_data["tags"] = data["tags"]
assert response_json == expected_response_data
def test_user_trips_qs(user):
trip_1 = create_trip(user, "trip 1")
trip_2 = create_trip(user, "trip 2")
someone_else, _ = get_or_create_user("someone-else")
trip_3 = create_trip(someone_else, "trip 3")
add_member_to_trip(user, trip_3)
_ = create_trip(someone_else, "unrelated trip")
assert set(user_trips_qs(user)) == {trip_1, trip_2, trip_3}
def test_delete_other_users_move(user, call_endpoint):
someone_else, _ = get_or_create_user("someone-else")
someone_elses_trip = create_trip(created_by=someone_else, title="Foo")
someone_elses_location_1 = create_location(someone_elses_trip, "foo", 51, 0)
someone_elses_location_2 = create_location(someone_elses_trip, "bar", 51, 0)
someone_elses_move = create_move(someone_elses_location_1, someone_elses_location_2)
response = call_endpoint(user=user, move_id=someone_elses_move.move_id)
assert response.status_code == 404
someone_elses_move.refresh_from_db()
assert someone_elses_move.is_deleted is False
def test_get_trips_for_user():
user_1, _ = get_or_create_user("1")
someone_else, _ = get_or_create_user("2")
_ = create_trip(someone_else, title="other secret trip we shouldn't see")
trip_1 = create_trip(user_1, title="trip 1")
trip_1.save_with_times(created_on=datetime(2018, 1, 1, tzinfo=pytz.UTC))
trip_2 = create_trip(user_1, title="trip 2")
trip_2.save_with_times(created_on=datetime(2018, 1, 2, tzinfo=pytz.UTC))
trips = get_trips_created_by_user(user=user_1)
assert trips == [trip_2, trip_1]
trips = get_trips_created_by_user(user=user_1, ascending=True)
assert trips == [trip_1, trip_2]
trip_1.is_deleted = True
trip_1.save()
assert [trip_2] == get_trips_created_by_user(user=user_1)
assert [trip_2, trip_1] == get_trips_created_by_user(user=user_1,
include_deleted=True)
def test_delete_trip():
user, _ = get_or_create_user("trip-owner")
trip = create_trip(user, title="test trip")
assert not trip.is_deleted
unrelated_user, _ = get_or_create_user("unrelated-user")
assert delete_trip(unrelated_user, trip) is False
trip.refresh_from_db()
assert not trip.is_deleted
trip_member, _ = get_or_create_user("trip-member")
add_member_to_trip(trip_member, trip)
assert delete_trip(trip_member, trip) is False
trip.refresh_from_db()
assert not trip.is_deleted
success = delete_trip(user, trip)
assert success
trip.refresh_from_db()
assert trip.is_deleted
def test_update_trip_not_allowed_fields():
user, _ = get_or_create_user("foo")
trip = create_trip(user, title="original title")
with pytest.raises(UpdateNotAllowed):
update_trip(user,
trip,
title="updated title",
foo="wtf is this field",
bar=[1, 2, 3])
trip.refresh_from_db()
assert trip.title == "original title"
def test_can_get_details_if_trip_member(trip):
member, _ = get_or_create_user("member")
add_member_to_trip(member, trip)
response = call_endpoint(member, trip.trip_id)
assert response.status_code == 200
assert {
"trip_id": str(trip.trip_id),
"title": "some trip",
"locations": [],
"created_on": "2019-01-01T10:00:00Z",
} == response.json()
def test_create_location_for_other_users_trip(trip):
assert no_models_in_db(Location)
someone_else, _ = get_or_create_user("someone-else")
response = call_endpoint(
user=someone_else,
trip_id=trip.trip_id,
data={
"display_name": "location name",
"lat": 51.5,
"lng": -0.12
},
)
assert response.status_code == 404
assert no_models_in_db(Location)
def test_create_trip():
user, _ = get_or_create_user("foo")
assert no_models_in_db(Trip)
assert no_models_in_db(TripMember)
trip = create_trip(user, title="test trip")
assert 1 == count_models_in_db(Trip)
assert 1 == count_models_in_db(TripMember)
trip_in_db = Trip.objects.all()[0]
assert trip == trip_in_db
assert trip.created_by == trip_in_db.created_by # only compares pk
assert trip.title == trip_in_db.title
trip_member_in_db = TripMember.objects.all()[0]
assert trip_member_in_db.user == user
assert trip_member_in_db.trip == trip_in_db
assert trip_member_in_db.is_admin
def test_create_move_with_other_users_location(call_endpoint, user, trip):
my_location = create_location(trip, "my location", 51, 0)
someone_else, _ = get_or_create_user("someone-else")
not_my_location = create_location(
trip=create_trip(someone_else, "someone elses trip", "test description"),
display_name="not my location",
lat=51,
lng=0,
)
response = call_endpoint(
user=user,
data={
"start_location_id": str(my_location.location_id),
"end_location_id": str(not_my_location.location_id),
},
)
assert response.status_code == 400
assert b"does not exist" in response.content
assert 0 == len(Move.objects.all())
def test_can_not_get_unowned_locations(trip):
someone_else, _ = get_or_create_user("someone-else")
location_1 = create_location(trip, "test location", lat=0, lng=0)
assert get_location_by_id(someone_else, location_1.location_id) is None
def user():
user, _ = get_or_create_user(external_id="test-id")
return user
def user():
user, _ = get_or_create_user("test-user")
return user
def test_is_user_member_of_trip(trip_owner, trip):
somebody, _ = get_or_create_user("test-user")
assert is_user_member_of_trip(trip_owner, trip) is True
assert is_user_member_of_trip(somebody, trip) is False
def trip_owner():
user, _ = get_or_create_user("user-1")
return user
def user_1():
user, _ = get_or_create_user("auth0-id-1", "*****@*****.**")
return user
def user_2():
user, _ = get_or_create_user("auth0-id-2", "*****@*****.**")
return user
def user():
user, _ = get_or_create_user(external_id="foo")
return user
