def test_dispatch_overdue_doesnt_include_joomla_orders(self):
order = factories.create_order(5, is_joomla_order=False)
self.make_order_days_old(order, 2)
joomla_order = factories.create_order(5, is_joomla_order=True)
self.make_order_days_old(joomla_order, 2)
result = Order.objects.dispatch_overdue(1)
self.assertEqual([o.id for o in result], [order.id])
def test_completed(self):
order1 = factories.create_order(3)
order2 = factories.create_order(5, dispatched=True)
completed = Order.objects.completed().all()
self.assertEqual(len(completed), 1)
self.assertEqual(completed[0].id, order2.id)
def setUp(self):
created = datetime.datetime.now().date() - datetime.timedelta(days=3)
self.ready_to_pay = factories.create_order(
5,
dispatched=True,
created=created,
payment_status=Payment.STATUS_PRIMARY_PAID,
)
self.overdue_orders = {}
for day in [3, 7, 13, 14, 15]:
delta = datetime.timedelta(days=day)
created = datetime.datetime.now().date() - delta
self.overdue_orders[day] = factories.create_order(
5,
dispatched=False,
created=created,
payment_status=Payment.STATUS_PRIMARY_PAID,
)
self.command = payments_cron.Command()
self.notify_patcher = mock.patch.object(payments_cron,
"notifier",
spec=True)
self.mock_notifier = self.notify_patcher.start()
self.addCleanup(self.notify_patcher.stop)
self.payment_patcher = mock.patch("purchase.models.Order.payment")
self.mock_payment = self.payment_patcher.start()
self.addCleanup(self.payment_patcher.stop)
self.refund_patcher = mock.patch("purchase.models.Order.refund")
self.mock_refund = self.refund_patcher.start()
self.addCleanup(self.refund_patcher.stop)
def test_feedback_given(self):
order1 = factories.create_order(3)
order2 = factories.create_order(3)
feedback = factories.FeedbackFactory(order=order1)
given = Order.objects.feedback_given().all()
self.assertEqual(len(given), 1)
self.assertEqual(given[0].id, order1.id)
def test_awaiting_feedback(self):
order1 = factories.create_order(3)
order2 = factories.create_order(4)
feedback = factories.FeedbackFactory(order=order1)
awaiting = Order.objects.awaiting_feedback().all()
self.assertEqual(len(awaiting), 1)
self.assertEqual(awaiting[0].id, order2.id)
def test_awaiting_shipping(self):
order1 = factories.create_order(3)
order2 = factories.create_order(4)
order2.mark_dispatched()
to_ship = Order.objects.awaiting_shipping().all()
self.assertEqual(len(to_ship), 1)
self.assertEqual(to_ship[0].id, order1.id)
def setUp(self):
self.needs_shipping = factories.create_order(5, dispatched=False)
self.shipped = factories.create_order(5,
dispatched=True,
stall=self.needs_shipping.stall)
self.stall = self.shipped.stall
self.user = self.stall.user
self.client.login(username=self.user.username, password="******")
def test_dispatch_overdue_if_subset_line_items_not_dispatched(self):
order = factories.create_order(5)
line_item = order.line_items.all()[0]
line_item.dispatched = True
line_item.save()
self.make_order_days_old(order, 3)
non_overdue_orders = factories.create_order(3)
result = Order.objects.dispatch_overdue(2).all()
self.assertEqual(len(result), 1)
self.assertEqual(result[0].id, order.id)
def test_ready_to_pay_doesnt_include_joomla_orders(self):
ready_to_pay = factories.create_order(
5, dispatched=True, payment_status=Payment.STATUS_PRIMARY_PAID)
self.make_order_days_old(ready_to_pay, 15)
joomla = factories.create_order(
3,
dispatched=True,
payment_status=Payment.STATUS_PRIMARY_PAID,
is_joomla_order=True,
)
self.make_order_days_old(joomla, 15)
to_pay = list(Order.objects.ready_to_pay(0).all())
self.assertEqual(to_pay, [ready_to_pay])
def test_dispatched_orders_not_paid(self):
ready_to_pay = factories.create_order(
5, dispatched=True, payment_status=Payment.STATUS_PRIMARY_PAID)
self.make_order_days_old(ready_to_pay, 15)
not_ready_to_pay = factories.create_order(5, dispatched=False)
already_paid = factories.create_order(
5, dispatched=True, payment_status=Payment.STATUS_COMPLETED)
payment = already_paid.payment
self.make_order_days_old(already_paid, 15)
to_pay = Order.objects.ready_to_pay(14).all()
self.assertEqual(len(to_pay), 1)
self.assertEqual(to_pay[0].id, ready_to_pay.id)
def setUp(self):
super(IpnPaymentCompleteTestCase, self).setUp()
self.view_url = reverse('ipn_handler')
self.order = factories.create_order(5)
self.ipn_data = json.loads(utils.load_fixture("payment_complete_ipn.json"))
self.ipn_data["pay_key"] = self.order.payment.pay_key
def setUp(self):
super(RefundViewTestCase, self).setUp()
self.order = factories.create_order(5)
self.user = self.order.stall.user
self.client.login(username=self.user.username, password="******")
self.patcher = mock.patch('apps.purchase.models.notifier')
self.patcher.start()
self.addCleanup(self.patcher.stop)
def test_is_dispatched_with_refunded_items(self):
order = factories.create_order(2, dispatched=True)
ref_line_item = order.line_items.all()[0]
refund = factories.RefundFactory(order=order)
ref_line_item.refund = refund
ref_line_item.dispatched = False
ref_line_item.save()
self.assertTrue(order.is_dispatched())
def test_dispatch_not_overdue_if_undispatched_item_refunded(self):
order = factories.create_order(4, dispatched=True)
self.make_order_days_old(order, 10)
line_item = order.line_items.all()[0]
refund = factories.RefundFactory(order=order)
line_item.refund = refund
line_item.dispatched = False
line_item.save()
result = Order.objects.dispatch_overdue(14)
self.assertEqual(len(result), 0)
def setUp(self):
super(IpnHandlerViewTestCase, self).setUp()
self.view_url = reverse('ipn_handler')
self.order = factories.create_order(5)
ipn_data = json.loads(utils.load_fixture("refund_ipn.json"))
ipn_data["pay_key"] = self.order.payment.pay_key
self.ipn_data = urlencode(ipn_data)
self.notifier_patcher = mock.patch('apps.purchase.models.notifier')
self.notifier_patcher.start()
self.addCleanup(self.notifier_patcher.stop)
def test_mark_dispatched_doesnt_mark_refunded_line_items(self):
order = factories.create_order(5)
refunded_line_item = order.line_items.all()[0]
refund = factories.RefundFactory(order=order)
refunded_line_item.refund = refund
refunded_line_item.save()
order.mark_dispatched()
for line_item in order.line_items.all():
if line_item.id == refunded_line_item.id:
self.assertFalse(line_item.dispatched, "refunded item should "
"not be dispatched")
else:
self.assertTrue(line_item.dispatched,
"unrefunded items should "
"be dispatched")
def setUp(self):
super(OrderRefundTestCase, self).setUp()
self.order = factories.create_order(5)
self.notifier_patcher = mock.patch("apps.purchase.models.notifier")
self.notifier_patcher.start()
self.addCleanup(self.notifier_patcher.stop)
def test_old_orders_are_complete(self):
order = factories.create_order(3, is_joomla_order=True)
completed = Order.objects.completed().all()
self.assertEqual([order.id], [c.id for c in completed])
def test_context_contains_order(self):
order = factories.create_order(5)
view_url = reverse('invoice', kwargs={"order_id": order.id})
r = self.client.get(view_url)
self.assertEqual(r.context["order"].id, order.id)
def test_dispatch_not_overdue_if_all_line_items_dispatched(self):
dispatched_order = factories.create_order(4, dispatched=True)
self.make_order_days_old(dispatched_order, 50)
result = Order.objects.dispatch_overdue(10).all()
self.assertEqual(len(result), 0)
def setUp(self):
super(MarkDispatchedTestCase, self).setUp()
self.order = factories.create_order(4)
self.view_url = reverse('mark_dispatched',
kwargs={'order_id': self.order.id})
def test_is_dispatched(self):
order = factories.create_order(5, dispatched=True)
self.assertTrue(order.is_dispatched())
def test_context_contains_order(self):
order = factories.create_order(5)
view_url = reverse('invoice', kwargs={"order_id": order.id})
r = self.client.get(view_url)
self.assertEqual(r.context["order"].id, order.id)
def test_is_dispatched_on_non_dispatched_order(self):
order = factories.create_order(2)
self.assertFalse(order.is_dispatched())
def test_old_orders_are_dispatched(self):
order = factories.create_order(4, is_joomla_order=True)
dispatched = Order.objects.dispatched()
self.assertEqual([order.id], [o.id for o in dispatched])
def test_mark_dispatched_marks_all_line_items(self):
order = factories.create_order(5)
order.mark_dispatched()
for line_item in order.line_items.all():
self.assertTrue(line_item.dispatched)
