def test_delete_saver_save(professionals: QuerySet):
"""Should save the provided slots."""
start = arrow.utcnow()
end = start.shift(hours=3)
professional = professionals.first()
slot = AvailabilitySlot()
slot.professional = professional
slot.start_datetime = start.datetime
slot.end_datetime = end.datetime
slot.save()
pk = slot.pk
slot.pk = None
request = Request()
request.professional = professionals.first()
request = RequestYearProcessor().get(request)
saver = DeleteSaver()
saver.set_request(request).set_slots([slot])
saver.save()
slots = AvailabilitySlot.objects.all()
assert slots.count() == 1
assert slot.pk != pk
assert saver.set_slots([]).save() is None # type: ignore
def test_calendar_validate_request(
professionals: QuerySet,
services: QuerySet,
):
"""Should validate a calendar request."""
request = CalendarRequest()
professional = professionals.first()
request.professional = professional
start = arrow.utcnow()
end = start.shift(hours=-1)
request.start_datetime = start
request.end_datetime = end
with pytest.raises(CalendarValidationError) as error:
validators.validate_calendar_request(request)
assert "start datetime" in str(error)
assert "end datetime" in str(error)
end = start.shift(hours=1)
request.end_datetime = end
validators.validate_calendar_request(request)
service = services.exclude(professional=professional).first()
request.service = service
with pytest.raises(CalendarValidationError) as error:
validators.validate_calendar_request(request)
assert "service" in str(error)
request.service = request.professional.services.first() # type: ignore
validators.validate_calendar_request(request)
def test_review_manager_get_professional_rating(
admin: User,
professionals: QuerySet,
):
"""Should return the professional rating."""
manager = Review.objects
user_manager = User.objects
professional = professionals.first()
assert manager.get_professional_rating(professional) is None
manager.create(
user=admin,
professional=professional,
description="description",
rating=4,
)
assert manager.get_professional_rating(professional) == Decimal(4.00)
manager.create(
user=user_manager.create_user("*****@*****.**", "pass"),
professional=professional,
description="description",
rating=5,
)
assert manager.get_professional_rating(professional) == Decimal(4.50)
manager.create(
user=user_manager.create_user("*****@*****.**", "pass"),
professional=professional,
description="description",
rating=1,
)
assert manager.get_professional_rating(professional) == Decimal(3.33)
def test_generate_for_service(
services: QuerySet,
mocker: MockFixture,
):
"""Should run the generator."""
service = services.first()
start = arrow.utcnow()
end = start.shift(days=1)
generator = mocker.MagicMock()
get_generator = mocker.MagicMock(return_value=generator)
mocker.patch(
"schedule.availability.utils.get_availability_generator",
new=get_generator,
)
generate_for_service(
service=service,
append_days=True,
start=start,
end=end,
)
get_generator.assert_called_once()
generator.generate.assert_called_once()
request = get_generator.call_args_list[0][0][0]
assert request.service == service
assert request.professional == service.professional
assert request.start_datetime == start
assert request.end_datetime == end
assert request.append_days is True
def messages(admin: User, user: User, users: QuerySet) -> QuerySet:
"""Return a messages queryset."""
user_one = users.first()
user_two = users[1]
for i in range(0, OBJECTS_TO_CREATE):
Message.objects.create(
sender=admin,
recipient=user,
subject=f"subject {i}",
body=f"message body {i}",
)
for i in range(0, OBJECTS_TO_CREATE):
Message.objects.create(
sender=user,
recipient=admin,
subject=f"subject {i}",
body=f"message body {i}",
)
for i in range(0, OBJECTS_TO_CREATE):
Message.objects.create(
sender=user_one,
recipient=user_two,
subject=f"subject user {i}",
body=f"message body user {i}",
)
for i in range(0, OBJECTS_TO_CREATE):
Message.objects.create(
sender=user_two,
recipient=user_one,
subject=f"subject user {i}",
body=f"message body user {i}",
)
return Message.objects.get_list()
def test_availability_request_year_processor(
professionals: QuerySet,
services: QuerySet,
):
"""Should set dates and a professional."""
service = services.first()
professional = professionals.exclude(pk=service.professional.pk).first()
request = Request()
request.service = service
request.professional = professional
processor = RequestYearProcessor()
new_request = processor.get(request)
assert new_request.professional == service.professional
assert new_request.start_datetime == arrow.utcnow().replace(
hour=0,
minute=0,
second=0,
microsecond=0,
)
assert new_request.end_datetime == arrow.utcnow().replace(
hour=0,
minute=0,
second=0,
microsecond=0,
).shift(years=1)
def test_category_display_de(client: Client, categories: QuerySet):
"""Should return a list of categories [de]."""
cat = categories.first()
with select_locale("de"):
response = client.get(reverse("categories-detail", args=[cat.pk]))
assert response.json()["name"] == cat.name_de
assert response.json()["description"] == cat.description_de
def test_category_display(client: Client, categories: QuerySet):
"""Should return a list of categories."""
cat = categories.first()
response = client.get(reverse("categories-detail", args=[cat.pk]))
assert response.status_code == 200
assert response.accepted_media_type == "application/json"
assert response.json()["name"] == cat.name_en
def test_user_sent_order_update_restricted_entry(
client_with_token: Client,
orders: QuerySet,
):
"""Should deny access to someone else"s record."""
obj = orders.first()
response = client_with_token.post(
reverse("user-orders-sent-detail", args=[obj.pk]), {"note": "new"})
assert response.status_code == 405
def test_services_manager_get_by_params(services: QuerySet):
"""Should return a service."""
expected = services.first()
service = Service.objects.get_by_params(
pk=expected.pk,
name=expected.name,
)
assert service == expected
assert Service.objects.get_by_params(pk=0) is None
def test_subcategory_list(client: Client, subcategories: QuerySet):
"""Should return a list of subcategories."""
subcat = subcategories.first()
response = client.get(reverse("subcategories-list"))
assert response.status_code == 200
assert response.accepted_media_type == "application/json"
assert response.json()["count"] == subcategories.count()
assert response.json()["results"][0]["name"] == "category 0: subcategory 0"
assert response.json()["results"][0]["category"] == subcat.category.pk
def test_professional_schedule_post_delete(
professional_schedules: QuerySet,
mocker: MockFixture,
):
"""Should run the availability generator."""
generator = mocker.patch("schedule.signals.generate_for_professional")
schedule = professional_schedules.first()
schedule.delete()
assert generator.call_count == 1
generator.assert_called_with(schedule.professional)
def test_professional_photos_list(
client_with_token: Client,
professional_photos: QuerySet,
):
"""Should return a professional photos list."""
obj = professional_photos.first()
response = client_with_token.get(reverse("professional-photos-list"))
data = response.json()
assert response.status_code == 200
assert data["count"] == professional_photos.count()
assert data["results"][0]["name"] == obj.name
def test_service_closed_period_post_delete(
service_closed_periods: QuerySet,
mocker: MockFixture,
):
"""Should run the availability generator."""
generator = mocker.patch("schedule.signals.generate_for_service")
closed_period = service_closed_periods.first()
closed_period.delete()
assert generator.call_count == 1
generator.assert_called_with(closed_period.service)
def test_professional_photos_detail(
client_with_token: Client,
professional_photos: QuerySet,
):
"""Should return a professional photos detail."""
obj = professional_photos.first()
response = client_with_token.get(
reverse("professional-photos-detail", args=[obj.pk]))
data = response.json()
assert response.status_code == 200
assert data["name"] == obj.name
def test_service_photos_list(
client_with_token: Client,
services: QuerySet,
):
"""Should return a service photos list."""
obj = services.first().photos.first()
response = client_with_token.get(reverse("service-photos-list"))
data = response.json()
assert response.status_code == 200
assert data["count"] == services.count()
assert data["results"][0]["name"] == obj.name
def test_service_photos_detail(
client_with_token: Client,
services: QuerySet,
):
"""Should return a service photo details."""
obj = services.first().photos.first()
response = client_with_token.get(
reverse("service-photos-detail", args=[obj.pk]))
data = response.json()
assert response.status_code == 200
assert data["description"] == obj.description
def test_service_schedule_post_save(
service_schedules: QuerySet,
mocker: MockFixture,
):
"""Should run the availability generator."""
generator = mocker.patch("schedule.signals.generate_for_service")
schedule = service_schedules.first()
schedule.is_enabled = False
schedule.save()
assert generator.call_count == 1
generator.assert_called_with(schedule.service)
def test_professional_closed_period_post_save(
professional_closed_periods: QuerySet,
mocker: MockFixture,
):
"""Should run the availability generator."""
generator = mocker.patch("schedule.signals.generate_for_professional")
closed_period = professional_closed_periods.first()
closed_period.is_enabled = False
closed_period.save()
assert generator.call_count == 1
generator.assert_called_with(closed_period.professional)
def test_suggested_messages_list(
client_with_token: Client,
suggested_messages: QuerySet,
):
"""Should return a list of suggested messages."""
message = suggested_messages.first()
response = client_with_token.get(reverse("messages-suggested-list"))
assert response.status_code == 200
assert response.accepted_media_type == "application/json"
assert response.json()["count"] == suggested_messages.count()
assert response.json()["results"][0]["name"] == message.name
def suggested_messages(subcategories: QuerySet) -> QuerySet:
"""Return a subcategories queryset."""
cat = subcategories.first()
for i in range(0, OBJECTS_TO_CREATE):
SuggestedMessage.objects.create(
subcategory=cat,
name_en=f"name {i}",
body_en=f"description {i}",
name_de=f"der name {i}",
body_de=f"beschreibung {i}",
)
return SuggestedMessage.objects.get_list()
def _build_team_profiles_list(profiles: (list, filter),
group: (Group, Company),
checked_profiles: QuerySet,
unbilding_user: list) -> list:
result = []
for profile in profiles:
if profile in unbilding_user:
continue
profile: Profile
collected_profile = build_profile(profile)
if type(checked_profiles.first()) == Profile:
collected_profile['is_checked'] = checked_profiles.filter(
id=profile.pk).exists()
elif type(checked_profiles.first()) == NeedPassPoll:
collected_profile['is_checked'] = checked_profiles.filter(
profile=profile).exists()
if group is not None:
collected_profile['is_leader'] = group.owner == profile
result.append(collected_profile)
return result
def test_services_detail(
client_with_token: Client,
services: QuerySet,
):
"""Should return a service details."""
obj = services.first()
response = client_with_token.get(reverse("services-detail", args=[obj.pk]))
data = response.json()
assert response.status_code == 200
assert data["name"] == obj.name
assert data["price"]["start_price"] == str(obj.price.start_price.amount)
assert len(data["tags"]) == obj.tags.count()
assert len(data["locations"]) == obj.locations.count()
def test_services_manager_get_min_duration(services: QuerySet):
"""Should return a minimum duration."""
professional = services.first().professional
manager = Service.objects
assert manager.get_min_duration(professional) == 60
manager.update(is_enabled=True)
service = services.filter(professional=professional).first()
service.duration = 15
service.save()
assert manager.get_min_duration(professional) == 15
manager.filter(professional=professional).delete()
assert manager.get_min_duration(professional) == 0
def test_message_manager_get_latest_distinct_messages(
admin: User,
user: User,
users: QuerySet,
messages: QuerySet,
):
"""Should return a list of user latest distinct messages."""
user_another = users.first()
def request() -> List[Message]:
"""Make request."""
return Message.objects.get_latest_distinct_messages(admin)
obj = messages.filter(Q(recipient=admin) | Q(sender=admin)).\
order_by("-created").first()
data = request()
assert len(data) == 1
assert data[0] == obj
Message.objects.create(
sender=admin,
recipient=user,
body="admin->user",
)
data = request()
assert len(data) == 1
assert data[0].body == "admin->user"
assert data[0].sender.email == admin.email
# Send message to the user from the another user
Message.objects.create(
sender=user_another,
recipient=admin,
body="another->user",
)
data = request()
assert len(data) == 2
assert data[0].body == "another->user"
assert data[0].sender.email == user_another.email
assert data[0].recipient.email == admin.email
# Delete message to the user from the another user
Message.objects.filter(
sender=user_another,
recipient=admin,
).update(is_deleted_from_recipient=True)
data = request()
assert len(data) == 1
def test_generate_for_order(
services: QuerySet,
mocker: MockFixture,
):
"""Should run the generator."""
service = services.first()
service.is_base_schedule = False
order = Order()
order.service = service
professional_generator = mocker.patch(
"schedule.availability.utils.generate_for_professional")
service_generator = mocker.patch(
"schedule.availability.utils.generate_for_service")
generate_for_order(order)
professional_generator.assert_called_once_with(order.service.professional)
service_generator.assert_called_once_with(order.service)
def test_update_professional_rating(
admin: User,
professionals: QuerySet,
):
"""Should update the professional rating."""
professional = professionals.first()
manager = Review.objects
manager.create(
user=admin,
professional=professional,
description="description",
rating=4,
)
update_professional_rating(professional)
professional.refresh_from_db()
assert professional.rating == Decimal(4.00)
def test_user_professionals_create(
user: User,
client_with_token: Client,
subcategories: QuerySet,
):
"""Should be able to create a user professional object."""
response = client_with_token.post(
reverse("user-professionals-list"),
{
"name": "test professional",
"description": "test professional description",
"subcategory": subcategories.first().pk
},
)
assert response.status_code == 201
assert user.professionals.first().name == "test professional"
def test_message_manager_get_interlocutors(
admin: User,
users: QuerySet,
messages: QuerySet,
):
"""Should return interlocutors."""
# pylint: disable=unused-argument
user_another = users.first()
Message.objects.create(
sender=user_another,
recipient=admin,
body="another->admin",
)
result = Message.objects.get_interlocutors(interlocutor=admin)
assert result.count() == 2
assert result[0].email == user_another.email
assert result[1].email == USER_EMAIL
def test_availability_request_validator(
professionals: QuerySet,
services: QuerySet,
):
"""Should validate a request."""
service = services.first()
professional = professionals.exclude(pk=service.professional.pk).first()
request = Request()
now = arrow.utcnow()
validator = RequestValidator()
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "datetime is invalid" in str(error)
request.start_datetime = now
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "datetime is invalid" in str(error)
request.end_datetime = request.start_datetime.shift(hours=-1)
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "be less" in str(error)
request.end_datetime = request.end_datetime.replace(
tzinfo="America/Toronto")
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "datetime is invalid" in str(error)
request.end_datetime = request.start_datetime.shift(months=1)
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "professional is empty" in str(error)
request.professional = professional
request.service = service
with pytest.raises(AvailabilityValueError) as error:
validator.validate(request)
assert "service is incorrect" in str(error)
request.professional = service.professional
validator.validate(request)
