def test_get_orders_of_user(self):
order = start_order(self.user, self.account)
order2 = start_order(self.user, self.account2)
order3 = start_order(self.user2, self.account)
orders = get_orders_of_user(self.user.id)
self.assertEqual(len(orders), 2)
self.assertIn(order, orders)
self.assertIn(order2, orders)
self.assertNotIn(order3, orders)
def test_started_orders(self):
order = start_order(self.user, self.account)
order2 = start_order(self.user2, self.account)
order3 = start_order(self.user, self.account2)
order4 = start_order(self.user2, self.account2)
started_order = get_started_order(self.user.id, self.account.id)
self.assertEqual(order, started_order)
self.assertNotEqual(order, order2)
self.assertNotEqual(order2, order3)
self.assertNotEqual(order3, order4)
def test_mail_tickets(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
order.checkout()
order.purchase()
create_tickets(order)
self.assertTrue(mail_order(order.id, fake=True))
def test_finish_order(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 9)
order.checkout()
finish_order(order, send_mail=False)
self.assertEqual(self.tickettype.availability, AVAILABLE)
self.assertEqual(len(order.get_tickets()), 9)
def test_updating_too_many(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
add_tickets(order, self.tickettype.id, 9)
add_tickets(order, self.tickettype.id, 10)
self.assertRaises(ex.AmountNotAvailableError, add_tickets, order,
self.tickettype.id, 11)
def test_add_tickets_to_order_with_no_user(self):
order = start_order(None, self.account)
add_tickets(order, self.tickettype.id, 5)
self.assertEqual(len(order.get_ticketorders()), 1)
self.assertEqual(order.get_ticketorders()[0].amount, 5)
self.assertEqual(order.get_ticketorders()[0].ticket_type_id,
self.tickettype.id)
def order_new(client_id,
user_id,
tickettype_id,
amount,
account_short=None,
as_guest=False,
as_paper=False):
"""
Starts a new order session or retrieves one that was still active.
Args:
client_id
user_id:
Id of the user to start a session for.
"""
timeout_sessions(600)
# assert permission to order tickettype
if client_id is not None:
require_tickettype_owner(client_id, tickettype_id)
# get account to create order for.
if account_short is not None:
account = lookup_account_by_name(account_short)
else:
account = lookup_account_for_client(client_id)
# start an order or get current one.
if user_id is not None:
user = lookup_user_by_id(user_id)
order = start_order(user, account)
else:
order = start_order(None, account)
# set order as guest (optional)
if as_guest:
order.meta['gifted'] = True
# set order as paper ticket (optional)
if as_paper:
order.meta['paper'] = True
add_tickets(order, tickettype_id, amount)
# build successful order
order_info = order_to_dict(order)
return order_info
def test_update_tickets(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
add_tickets(order, self.tickettype.id, 4)
self.assertEqual(len(order.get_ticketorders()), 1)
self.assertEqual(order.get_ticketorders()[0].amount, 4)
self.assertEqual(order.get_ticketorders()[0].ticket_type_id,
self.tickettype.id)
def test_mail_bad_address(self):
self.user.email = "badmail"
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
order.checkout()
order.purchase()
create_tickets(order)
self.assertFalse(mail_order(order.id, fake=True))
def test_dont_timeout_purchased_orders(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
order.checkout()
order.purchase()
self.assertEqual(order.status, PURCHASED)
timeout_sessions(0)
self.assertEqual(order.status, PURCHASED)
def test_start_two_same_orders(self):
order1 = start_order(self.user, self.account)
order2 = start_order(self.user, self.account)
self.assertEqual(order1, order2)
self.assertEqual(order1.order_key, order2.order_key)
def test_start_two_seperate_orders_by_user(self):
order1 = start_order(self.user, self.account)
order2 = start_order(self.user, self.account2)
self.assertNotEqual(order1, order2)
self.assertNotEqual(order1.order_key, order2.order_key)
def test_start_order(self):
order = start_order(self.user, self.account)
self.assertEqual(order.account, self.account)
self.assertEqual(order.user, self.user)
self.assertEqual(order.status, STARTED)
def test_finish_unbound_full_order(self):
order = start_order(None, self.account)
add_tickets(order, self.tickettype.id, 10)
self.assertRaises(ex.OrderError, order.checkout)
def test_finish_binding_full_order(self):
order = start_order(None, self.account)
add_tickets(order, self.tickettype.id, 10)
order.checkout(self.user)
def test_adding_zero(self):
order = start_order(self.user, self.account)
self.assertRaises(ex.AmountNotAvailableError, add_tickets, order,
self.tickettype.id, 0)
def test_finish_unlocked_order(self):
order = start_order(self.user, self.account)
self.assertRaises(ex.OrderError, finish_order, order, send_mail=False)
def test_add_free_tickets(self):
order = start_order(self.user, self.account)
add_tickets(order, self.free_tickettype.id, 5)
def test_add_tickets_to_locked_order(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
order.lock()
self.assertRaises(ex.OrderLockedError, add_tickets, order,
self.tickettype.id, 5)
def test_add_free_tickets_when_no_transaction_available(self):
order = start_order(self.user, self.account)
get_or_create_transaction_statistic(self.account).amount = 500
add_tickets(order, self.free_tickettype.id, 5)
def test_add_tickets_when_no_transactions_available(self):
order = start_order(self.user, self.account)
get_or_create_transaction_statistic(self.account).amount = 500
self.assertRaises(ex.SubscriptionError, add_tickets, order,
self.tickettype.id, 5)
def test_remove_on_update_to_zero(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 5)
self.assertEqual(len(order.ordered_tickets.all()), 1)
add_tickets(order, self.tickettype.id, 0)
self.assertEqual(len(order.ordered_tickets.all()), 0)
def test_start_order_late_user_binding(self):
order = start_order(None, self.account)
order2 = start_order(None, self.account)
self.assertNotEqual(order, order2)
def test_get_order_by_id(self):
order = start_order(self.user, self.account)
order2 = start_order(self.user2, self.account)
found_order = lookup_order_by_id(order.id)
self.assertEqual(order, found_order)
self.assertNotEqual(found_order, order2)
def test_no_tickets(self):
order = start_order(self.user, self.account)
self.assertEqual(len(order.get_ticketorders()), 0)
def test_adding_inactive_tickettype(self):
order = start_order(self.user, self.account)
self.assertRaises(ex.InactiveTicketTypeError, add_tickets, order,
self.inactive_tickettype.id, 5)
def test_finish_full_order(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 10)
order.checkout()
finish_order(order, send_mail=False)
self.assertEqual(self.tickettype.availability, SOLD)
def test_claiming_all_tickets(self):
order = start_order(self.user, self.account)
add_tickets(order, self.tickettype.id, 10)
self.assertEqual(self.tickettype.availability, CLAIMED)
def test_get_order_by_payment_key(self):
order = start_order(self.user, self.account)
order2 = start_order(self.user2, self.account)
found_order = lookup_order_by_payment_key(order.payment_key)
self.assertEqual(order, found_order)
self.assertNotEqual(found_order, order2)
def test_adding_someone_elses_tickettype(self):
order = start_order(self.user, self.account)
self.assertRaises(ex.AccountError, add_tickets, order,
self.another_tickettype.id, 5)
