def test_revoke_tickets(self):
tickets_before = ticket_creation_service \
.create_tickets(self.category_id, self.owner_id, 3)
for ticket_before in tickets_before:
assert not ticket_before.revoked
events_before = event_service.get_events_for_ticket(
ticket_before.id)
assert len(events_before) == 0
# -------------------------------- #
ticket_ids = {ticket.id for ticket in tickets_before}
ticket_revocation_service.revoke_tickets(ticket_ids, self.admin_id)
# -------------------------------- #
tickets_after = ticket_service.find_tickets(ticket_ids)
for ticket_after in tickets_after:
assert ticket_after.revoked
events_after = event_service.get_events_for_ticket(ticket_after.id)
assert len(events_after) == 1
ticket_revoked_event = events_after[0]
assert ticket_revoked_event.event_type == 'ticket-revoked'
assert ticket_revoked_event.data == {
'initiator_id': str(self.admin_id),
}
def test_check_in_user(self):
ticket_before = ticket_service.create_ticket(self.category_id, self.owner_id)
ticket_before.used_by_id = self.user_id
self.db.session.commit()
assert not ticket_before.user_checked_in
events_before = event_service.get_events_for_ticket(ticket_before.id)
assert len(events_before) == 0
# -------------------------------- #
ticket_id = ticket_before.id
ticket_service.check_in_user(ticket_id, self.orga_id)
# -------------------------------- #
ticket_after = ticket_service.find_ticket(ticket_id)
assert ticket_before.user_checked_in
events_after = event_service.get_events_for_ticket(ticket_after.id)
assert len(events_after) == 1
ticket_revoked_event = events_after[0]
assert ticket_revoked_event.event_type == 'user-checked-in'
assert ticket_revoked_event.data == {
'checked_in_user_id': str(self.user_id),
'initiator_id': str(self.orga_id),
}
def test_revoke_ticket_with_seat(self):
area = seating_area_service.create_area(self.party.id, 'main', 'Main')
seat = seat_service.create_seat(area, 0, 0, self.category_id)
ticket = ticket_creation_service \
.create_ticket(self.category_id, self.owner_id)
ticket_seat_management_service \
.occupy_seat(ticket.id, seat.id, self.owner_id)
assert ticket.occupied_seat_id == seat.id
events_before = event_service.get_events_for_ticket(ticket.id)
event_types_before = {event.event_type for event in events_before}
assert 'seat-released' not in event_types_before
# -------------------------------- #
ticket_revocation_service.revoke_ticket(ticket.id, self.admin_id)
# -------------------------------- #
assert ticket.occupied_seat_id is None
events_after = event_service.get_events_for_ticket(ticket.id)
event_types_after = {event.event_type for event in events_after}
assert 'seat-released' in event_types_after
def test_revoke_ticket(self):
ticket_before = ticket_service.create_ticket(self.category_id,
self.owner_id)
assert not ticket_before.revoked
events_before = event_service.get_events_for_ticket(ticket_before.id)
assert len(events_before) == 0
# -------------------------------- #
ticket_id = ticket_before.id
ticket_service.revoke_ticket(ticket_id)
# -------------------------------- #
ticket_after = ticket_service.find_ticket(ticket_id)
assert ticket_after.revoked
events_after = event_service.get_events_for_ticket(ticket_after.id)
assert len(events_after) == 1
ticket_revoked_event = events_after[0]
assert ticket_revoked_event.event_type == 'ticket-revoked'
assert ticket_revoked_event.data == {}
def test_revoke_bundle(self):
tickets_before = bundle_service.find_tickets_for_bundle(self.bundle_id)
assert len(tickets_before) == self.quantity
for ticket_before in tickets_before:
assert not ticket_before.revoked
events_before = event_service.get_events_for_ticket(ticket_before.id)
assert len(events_before) == 0
# -------------------------------- #
bundle_service.revoke_bundle(self.bundle_id)
# -------------------------------- #
tickets_after = bundle_service.find_tickets_for_bundle(self.bundle_id)
assert len(tickets_after) == self.quantity
for ticket_after in tickets_after:
assert ticket_after.revoked
events_after = event_service.get_events_for_ticket(ticket_after.id)
assert len(events_after) == 1
ticket_revoked_event = events_after[0]
assert ticket_revoked_event.event_type == 'ticket-revoked'
assert ticket_revoked_event.data == {}
def test_appoint_and_withdraw_user(self):
user = self.create_user('Ticket_User')
assert self.ticket.used_by_id is None
# appoint user
ticket_service.appoint_user(self.ticket.id, user.id, self.owner.id)
assert self.ticket.used_by_id == user.id
events_after_appointment = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_appointment) == 1
appointment_event = events_after_appointment[0]
assert appointment_event.event_type == 'user-appointed'
assert appointment_event.data == {
'appointed_user_id': str(user.id),
'initiator_id': str(self.owner.id),
}
# withdraw user
ticket_service.withdraw_user(self.ticket.id, self.owner.id)
assert self.ticket.used_by_id is None
events_after_withdrawal = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_withdrawal) == 2
withdrawal_event = events_after_withdrawal[1]
assert withdrawal_event.event_type == 'user-withdrawn'
assert withdrawal_event.data == {
'initiator_id': str(self.owner.id),
}
def test_occupy_and_release_seat(self):
area = self.create_area('main', 'Main Hall')
seat1 = seat_service.create_seat(area, 0, 1, self.category_id)
seat2 = seat_service.create_seat(area, 0, 2, self.category_id)
assert self.ticket.occupied_seat_id is None
# occupy seat
ticket_seat_management_service \
.occupy_seat(self.ticket.id, seat1.id, self.owner.id)
assert self.ticket.occupied_seat_id == seat1.id
events_after_occupation = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_occupation) == 1
occupation_event = events_after_occupation[0]
assert_event(occupation_event, 'seat-occupied', {
'seat_id': str(seat1.id),
'initiator_id': str(self.owner.id),
})
# switch to another seat
ticket_seat_management_service \
.occupy_seat(self.ticket.id, seat2.id, self.owner.id)
assert self.ticket.occupied_seat_id == seat2.id
events_after_switch = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_switch) == 2
switch_event = events_after_switch[1]
assert_event(
switch_event, 'seat-occupied', {
'previous_seat_id': str(seat1.id),
'seat_id': str(seat2.id),
'initiator_id': str(self.owner.id),
})
# release seat
ticket_seat_management_service \
.release_seat(self.ticket.id, self.owner.id)
assert self.ticket.occupied_seat_id is None
events_after_release = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_release) == 3
release_event = events_after_release[2]
assert_event(release_event, 'seat-released', {
'seat_id': str(seat2.id),
'initiator_id': str(self.owner.id),
})
def test_revoke_tickets_with_seats(self):
area = seating_area_service.create_area(self.party.id, 'main', 'Main')
tickets = ticket_creation_service.create_tickets(
self.category_id, self.owner_id, 2)
ticket_ids = {ticket.id for ticket in tickets}
for ticket in tickets:
seat = seat_service.create_seat(area, 0, 0, self.category_id)
ticket_seat_management_service.occupy_seat(ticket.id, seat.id,
self.owner_id)
assert ticket.occupied_seat_id == seat.id
# -------------------------------- #
ticket_revocation_service.revoke_tickets(ticket_ids, self.admin_id)
# -------------------------------- #
for ticket in tickets:
assert ticket.occupied_seat_id is None
events_after = event_service.get_events_for_ticket(ticket.id)
event_types_after = {event.event_type for event in events_after}
assert 'seat-released' in event_types_after
def test_appoint_and_withdraw_seat_manager(self):
manager = create_user('Ticket_Manager')
assert self.ticket.seat_managed_by_id is None
# appoint seat manager
ticket_seat_management_service.appoint_seat_manager(
self.ticket.id, manager.id, self.owner.id
)
assert self.ticket.seat_managed_by_id == manager.id
events_after_appointment = event_service.get_events_for_ticket(
self.ticket.id
)
assert len(events_after_appointment) == 1
appointment_event = events_after_appointment[0]
assert_event(
appointment_event,
'seat-manager-appointed',
{
'appointed_seat_manager_id': str(manager.id),
'initiator_id': str(self.owner.id),
},
)
# withdraw seat manager
ticket_seat_management_service.withdraw_seat_manager(
self.ticket.id, self.owner.id
)
assert self.ticket.seat_managed_by_id is None
events_after_withdrawal = event_service.get_events_for_ticket(
self.ticket.id
)
assert len(events_after_withdrawal) == 2
withdrawal_event = events_after_withdrawal[1]
assert_event(
withdrawal_event,
'seat-manager-withdrawn',
{'initiator_id': str(self.owner.id)},
)
def test_revoke_bundle(admin_app_with_db, normal_user, admin_user):
brand = create_brand()
party = create_party(brand_id=brand.id)
quantity = 4
owner = normal_user
bundle = create_bundle(party.id, quantity, owner)
tickets_before = bundle_service.find_tickets_for_bundle(bundle.id)
assert len(tickets_before) == quantity
for ticket_before in tickets_before:
assert not ticket_before.revoked
events_before = event_service.get_events_for_ticket(ticket_before.id)
assert len(events_before) == 0
# -------------------------------- #
bundle_service.revoke_bundle(bundle.id, admin_user.id)
# -------------------------------- #
tickets_after = bundle_service.find_tickets_for_bundle(bundle.id)
assert len(tickets_after) == quantity
for ticket_after in tickets_after:
assert ticket_after.revoked
events_after = event_service.get_events_for_ticket(ticket_after.id)
assert len(events_after) == 1
ticket_revoked_event = events_after[0]
assert ticket_revoked_event.event_type == 'ticket-revoked'
assert ticket_revoked_event.data == {
'initiator_id': str(admin_user.id),
}
def test_appoint_and_withdraw_user(self):
user = create_user('Ticket_User')
assert self.ticket.used_by_id is None
# appoint user
ticket_user_management_service \
.appoint_user(self.ticket.id, user.id, self.owner.id)
assert self.ticket.used_by_id == user.id
events_after_appointment = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_appointment) == 1
appointment_event = events_after_appointment[0]
assert_event(
appointment_event, 'user-appointed', {
'appointed_user_id': str(user.id),
'initiator_id': str(self.owner.id),
})
# withdraw user
ticket_user_management_service \
.withdraw_user(self.ticket.id, self.owner.id)
assert self.ticket.used_by_id is None
events_after_withdrawal = event_service.get_events_for_ticket(
self.ticket.id)
assert len(events_after_withdrawal) == 2
withdrawal_event = events_after_withdrawal[1]
assert_event(withdrawal_event, 'user-withdrawn', {
'initiator_id': str(self.owner.id),
})
