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)