CGM_Public/pretix_original
2
0
Fork 1
mirror of https://github.com/pretix/pretix.git synced 2026-05-05 15:14:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
cda8144ff0cb84dec9f7c0cbcb2012bab345f2e0
pretix_original/src/tests/base/test_memberships.py
Raphael Michel f532853021 Memberships: Prefer valid_from over event date for .is_valid() (#4003) 
* Memberships: Prefer valid_from over event date for .is_valid()

* Fix tests

* Add parameter description

* Use reasonable default for requested_valid_from if membership starts in the future

* Set datetimepicker viewDate to closest allowed date

* Keep current value on going back to QuestionsStep

* Fix min_date/max_date in SplitDateTimePickerWidget

* Remove unused import

* Update src/pretix/base/models/memberships.py

Co-authored-by: Mira <weller@rami.io>

* Respect variations

---------

Co-authored-by: Mira Weller <weller@rami.io>
2024-03-27 12:11:20 +01:00

813 lines
26 KiB
Python
Raw Blame History

#
# This file is part of pretix (Community Edition).
#
# Copyright (C) 2014-2020 Raphael Michel and contributors
# Copyright (C) 2020-2021 rami.io GmbH and contributors
#
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
# Public License as published by the Free Software Foundation in version 3 of the License.
#
# ADDITIONAL TERMS APPLY: Pursuant to Section 7 of the GNU Affero General Public License, additional terms are
# applicable granting you additional permissions and placing additional restrictions on your usage of this software.
# Please refer to the pretix LICENSE file to obtain the full terms applicable to this work. If you did not receive
# this file, see <https://pretix.eu/about/en/license>.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along with this program. If not, see
# <https://www.gnu.org/licenses/>.
#
from datetime import datetime, timedelta
from decimal import Decimal
from zoneinfo import ZoneInfo
import pytest
from django.conf import settings
from django.core.exceptions import ValidationError
from django.utils.timezone import now
from django_scopes import scope
from freezegun import freeze_time
from pretix.base.i18n import language
from pretix.base.models import (
CartPosition, Event, Item, Order, OrderPosition, Organizer,
)
from pretix.base.services.memberships import (
membership_validity, validate_memberships_in_order,
)
from pretix.base.services.orders import (
OrderError, _create_order, _perform_order,
)
from pretix.plugins.banktransfer.payment import BankTransfer
TZ = ZoneInfo('Europe/Berlin')
@pytest.fixture(scope='function')
def event():
o = Organizer.objects.create(name='Dummy', slug='dummy')
o.settings.customer_accounts = True
event = Event.objects.create(
organizer=o, name='Dummy', slug='dummy',
date_from=datetime(2021, 4, 27, 10, 0, 0, 0, tzinfo=TZ),
date_to=datetime(2021, 4, 28, 10, 0, 0, 0, tzinfo=TZ),
presale_end=datetime(2221, 4, 28, 10, 0, 0, 0, tzinfo=TZ),
plugins='pretix.plugins.banktransfer'
)
event.settings.timezone = 'Europe/Berlin'
with scope(organizer=o), language('en'):
yield event
@pytest.fixture
def customer(event):
return event.organizer.customers.create(email="john@example.org")
@pytest.fixture
def membership_type(event):
return event.organizer.membership_types.create(name="Full pass")
@pytest.fixture
def membership(event, membership_type, customer):
return customer.memberships.create(
membership_type=membership_type,
date_start=datetime(2021, 4, 1, 0, 0, 0, 0, tzinfo=TZ),
date_end=datetime(2021, 4, 30, 23, 59, 59, 999999, tzinfo=TZ),
)
@pytest.fixture
def granting_ticket(event, membership_type):
return Item.objects.create(
event=event, name='Full pass',
default_price=Decimal('23.00'),
admission=True,
grant_membership_type=membership_type,
)
@pytest.fixture
def requiring_ticket(event, membership_type):
i = Item.objects.create(
event=event, name='Day ticket',
default_price=Decimal('23.00'),
admission=True,
require_membership=True,
)
i.require_membership_types.add(membership_type)
return i
@pytest.fixture
def subevent(event):
event.has_subevents = True
return event.subevents.create(
name='Foo',
date_from=datetime(2021, 4, 29, 10, 0, 0, 0, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validity_membership_duration_like_event(event, granting_ticket, membership_type):
granting_ticket.grant_membership_duration_like_event = True
assert membership_validity(granting_ticket, None, event) == (
datetime(2021, 4, 27, 10, 0, 0, 0, tzinfo=TZ),
datetime(2021, 4, 28, 10, 0, 0, 0, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validity_membership_duration_like_subevent_without_end(event, granting_ticket, subevent, membership_type):
granting_ticket.grant_membership_duration_like_event = True
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 4, 29, 10, 0, 0, 0, tzinfo=TZ),
datetime(2021, 4, 29, 23, 59, 59, 999999, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validity_membership_duration_days(event, granting_ticket, membership_type):
granting_ticket.grant_membership_duration_like_event = False
granting_ticket.grant_membership_duration_days = 3
with freeze_time("2021-04-10T11:00:00+02:00"):
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 4, 10, 0, 0, 0, 0, tzinfo=TZ),
datetime(2021, 4, 12, 23, 59, 59, 999999, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validity_membership_duration_months(event, granting_ticket, membership_type):
granting_ticket.grant_membership_duration_like_event = False
granting_ticket.grant_membership_duration_months = 1
with freeze_time("2021-02-01T11:00:00+01:00"):
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 2, 1, 0, 0, 0, 0, tzinfo=TZ),
datetime(2021, 2, 28, 23, 59, 59, 999999, tzinfo=TZ),
)
with freeze_time("2021-02-28T11:00:00+01:00"):
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 2, 28, 0, 0, 0, 0, tzinfo=TZ),
datetime(2021, 3, 27, 23, 59, 59, 999999, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validity_membership_duration_months_plus_days(event, granting_ticket, membership_type):
granting_ticket.grant_membership_duration_like_event = False
granting_ticket.grant_membership_duration_months = 1
granting_ticket.grant_membership_duration_days = 2
with freeze_time("2021-02-01T11:00:00+01:00"):
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 2, 1, 0, 0, 0, 0, tzinfo=TZ),
datetime(2021, 3, 2, 23, 59, 59, 999999, tzinfo=TZ),
)
with freeze_time("2021-02-28T11:00:00+01:00"):
assert membership_validity(granting_ticket, subevent, event) == (
datetime(2021, 2, 28, 0, 0, 0, 0, tzinfo=TZ),
datetime(2021, 3, 29, 23, 59, 59, 999999, tzinfo=TZ),
)
@pytest.mark.django_db
def test_validate_membership_not_required(event, customer, membership, granting_ticket, membership_type):
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=granting_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None
)
assert "does not require" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_required(event, customer, membership, requiring_ticket, membership_type):
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
)
],
event,
lock=False,
ignored_order=None
)
assert "requires an active" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_ensure_locking(event, customer, membership, requiring_ticket, membership_type, django_assert_num_queries):
with django_assert_num_queries(4) as captured:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=True,
ignored_order=None
)
if 'sqlite' not in settings.DATABASES['default']['ENGINE']:
assert any('FOR UPDATE' in s['sql'] for s in captured)
@pytest.mark.django_db
def test_validate_membership_canceled(event, customer, membership, requiring_ticket, membership_type):
with pytest.raises(ValidationError) as excinfo:
membership.canceled = True
membership.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None,
testmode=False,
)
assert "canceled" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_test_mode(event, customer, membership, requiring_ticket, membership_type):
with pytest.raises(ValidationError) as excinfo:
membership.testmode = True
membership.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None,
testmode=False,
)
assert "test mode" in str(excinfo.value)
with pytest.raises(ValidationError) as excinfo:
membership.testmode = False
membership.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None,
testmode=True,
)
assert "test mode" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_wrong_customer(event, customer, membership, requiring_ticket, membership_type):
customer2 = event.organizer.customers.create(email="doe@example.org")
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer2,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None
)
assert "different customer" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_wrong_date(event, customer, membership, requiring_ticket, membership_type):
membership.date_start -= timedelta(days=100)
membership.date_end -= timedelta(days=100)
membership.save()
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None
)
assert "taking place at" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_wrong_type(event, customer, membership, requiring_ticket, membership_type):
requiring_ticket.require_membership_types.clear()
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None
)
assert "not allowed for the product" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_max_usages(event, customer, membership, requiring_ticket, membership_type):
membership_type.max_usages = 1
membership_type.allow_parallel_usage = True
membership_type.save()
o1 = Order.objects.create(
status=Order.STATUS_PENDING,
event=event,
email='admin@localhost',
datetime=now() - timedelta(days=3),
expires=now() + timedelta(days=11),
total=Decimal("23"),
)
OrderPosition.objects.create(
order=o1,
item=requiring_ticket,
used_membership=membership,
variation=None,
price=Decimal("23"),
attendee_name_parts={'full_name': "Peter"}
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None
)
assert "more than 1 time" in str(excinfo.value)
membership_type.max_usages = 2
membership_type.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
)
],
event,
lock=False,
ignored_order=None
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
),
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership
),
],
event,
lock=False,
ignored_order=None
)
assert "more than 2 times" in str(excinfo.value)
@pytest.mark.django_db
def test_validate_membership_parallel(event, customer, membership, subevent, requiring_ticket, membership_type):
se2 = event.subevents.create(
name='Foo',
date_from=datetime(2021, 4, 28, 10, 0, 0, 0, tzinfo=TZ),
)
membership_type.allow_parallel_usage = False
membership_type.save()
o1 = Order.objects.create(
status=Order.STATUS_PENDING,
event=event,
email='admin@localhost',
datetime=now() - timedelta(days=3),
expires=now() + timedelta(days=11),
total=Decimal("23"),
)
OrderPosition.objects.create(
order=o1,
item=requiring_ticket,
used_membership=membership,
variation=None,
subevent=subevent,
price=Decimal("23"),
attendee_name_parts={'full_name': "Peter"}
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
subevent=subevent
)
],
event,
lock=False,
ignored_order=None
)
assert "different ticket at the same time" in str(excinfo.value)
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
subevent=se2
)
],
event,
lock=False,
ignored_order=None
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
subevent=se2
),
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
subevent=se2
)
],
event,
lock=False,
ignored_order=None
)
assert "different ticket at the same time" in str(excinfo.value)
membership_type.allow_parallel_usage = True
membership_type.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
subevent=subevent
)
],
event,
lock=False,
ignored_order=None
)
@pytest.mark.django_db
def test_validate_membership_parallel_validity_dynamic(event, customer, membership, requiring_ticket, membership_type):
requiring_ticket.validity_mode = Item.VALIDITY_MODE_DYNAMIC
requiring_ticket.validity_dynamic_start_choice = False
requiring_ticket.validity_dynamic_duration_days = 1
requiring_ticket.save()
membership_type.allow_parallel_usage = False
membership_type.save()
membership.date_end = now() + timedelta(days=900)
membership.save()
o1 = Order.objects.create(
status=Order.STATUS_PENDING,
event=event,
email='admin@localhost',
datetime=now() - timedelta(days=3),
expires=now() + timedelta(days=11),
total=Decimal("23"),
)
OrderPosition.objects.create(
order=o1,
item=requiring_ticket,
used_membership=membership,
variation=None,
price=Decimal("23"),
attendee_name_parts={'full_name': "Peter"},
valid_from=now(),
valid_until=now().replace(hour=23, minute=59, second=59),
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None
)
assert "different ticket that overlaps" in str(excinfo.value)
requiring_ticket.validity_dynamic_start_choice = True
requiring_ticket.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None,
valid_from_not_chosen=True
)
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None,
valid_from_not_chosen=False
)
assert "different ticket that overlaps" in str(excinfo.value)
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
requested_valid_from=now() + timedelta(days=1)
)
],
event,
lock=False,
ignored_order=None,
)
membership_type.allow_parallel_usage = True
membership_type.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None
)
@pytest.mark.django_db
def test_validate_membership_parallel_validity_fixed(event, customer, membership, requiring_ticket, membership_type):
event.date_from = datetime(2021, 1, 1, 0, 0, 0, 0, tzinfo=TZ)
event.save()
requiring_ticket.validity_mode = Item.VALIDITY_MODE_FIXED
requiring_ticket.validity_fixed_from = now().replace(hour=2, minute=20, second=0)
requiring_ticket.validity_fixed_until = now().replace(hour=6, minute=20, second=0)
requiring_ticket.save()
membership_type.allow_parallel_usage = False
membership_type.save()
membership.date_end = now() + timedelta(days=900)
membership.save()
o1 = Order.objects.create(
status=Order.STATUS_PENDING,
event=event,
email='admin@localhost',
datetime=now() - timedelta(days=3),
expires=now() + timedelta(days=11),
total=Decimal("23"),
)
OrderPosition.objects.create(
order=o1,
item=requiring_ticket,
used_membership=membership,
variation=None,
price=Decimal("23"),
attendee_name_parts={'full_name': "Peter"},
valid_from=now().replace(hour=2, minute=20, second=0),
valid_until=now().replace(hour=6, minute=20, second=0),
)
requiring_ticket.validity_fixed_from = now().replace(hour=5, minute=20, second=0)
requiring_ticket.validity_fixed_until = now().replace(hour=8, minute=20, second=0)
requiring_ticket.save()
with pytest.raises(ValidationError) as excinfo:
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None
)
assert "different ticket that overlaps" in str(excinfo.value)
requiring_ticket.validity_fixed_from = now().replace(hour=6, minute=20, second=1)
requiring_ticket.validity_fixed_until = now().replace(hour=8, minute=20, second=0)
requiring_ticket.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None,
valid_from_not_chosen=True
)
requiring_ticket.validity_fixed_from = now().replace(hour=0, minute=20, second=0)
requiring_ticket.validity_fixed_until = now().replace(hour=1, minute=20, second=0)
requiring_ticket.save()
validate_memberships_in_order(
customer,
[
CartPosition(
event=event,
item=requiring_ticket,
used_membership=membership,
)
],
event,
lock=False,
ignored_order=None,
valid_from_not_chosen=True
)
@pytest.mark.django_db
def test_use_membership(event, customer, membership, requiring_ticket):
cp1 = CartPosition.objects.create(
item=requiring_ticket, price=23, expires=now() + timedelta(days=1), event=event, cart_id="123",
used_membership=membership
)
order = _create_order(event, email='dummy@example.org', positions=[cp1],
now_dt=now(),
payment_requests=[{
"id": "test0",
"provider": "banktransfer",
"max_value": None,
"min_value": None,
"multi_use_supported": False,
"info_data": {},
"payment_amount": Decimal("23.00"),
"pprov": BankTransfer(event)
}],
locale='de', customer=customer)[0]
assert order.positions.first().used_membership == membership
@pytest.mark.django_db
def test_use_membership_invalid(event, customer, membership, requiring_ticket):
membership.date_start -= timedelta(days=100)
membership.date_end -= timedelta(days=100)
membership.save()
cp1 = CartPosition.objects.create(
item=requiring_ticket, price=23, expires=now() + timedelta(days=1), event=event, cart_id="123",
used_membership=membership
)
with pytest.raises(OrderError) as excinfo:
_perform_order(event, email='dummy@example.org', position_ids=[cp1.pk],
payment_requests=[{
"id": "test0",
"provider": "banktransfer",
"max_value": None,
"min_value": None,
"multi_use_supported": False,
"info_data": {},
}],
address=None,
locale='de', customer=customer.pk)[0]
assert 'membership' in str(excinfo.value)
@pytest.mark.django_db
def test_grant_when_paid_and_changed(event, customer, granting_ticket):
cp1 = CartPosition.objects.create(
item=granting_ticket, price=23, expires=now() + timedelta(days=1), event=event, cart_id="123",
)
q = event.quotas.create(size=None, name="foo")
q.items.add(granting_ticket)
order = _create_order(event, email='dummy@example.org', positions=[cp1],
now_dt=now(),
payment_requests=[{
"id": "test0",
"provider": "banktransfer",
"max_value": None,
"min_value": None,
"multi_use_supported": False,
"info_data": {},
"pprov": BankTransfer(event),
"payment_amount": Decimal("23.00"),
}],
locale='de', customer=customer)[0]
assert not customer.memberships.exists()
order.payments.first().confirm()
m = customer.memberships.get()
assert m.granted_in == order.positions.first()
assert m.membership_type == granting_ticket.grant_membership_type
assert m.date_start == datetime(2021, 4, 27, 10, 0, 0, 0, tzinfo=TZ)
assert m.date_end == datetime(2021, 4, 28, 10, 0, 0, 0, tzinfo=TZ)
Reference in New Issue View Git Blame Copy Permalink