from registrasion.controllers.cart import CartController

from registrasion import models as rego

from django.core.exceptions import ObjectDoesNotExist

class TestingCartController(CartController):

    def set_quantity(self, product, quantity, batched=False):

        ''' Sets the _quantity_ of the given _product_ in the cart to the given

        _quantity_. '''

        self.set_quantities(((product, quantity),))

    def add_to_cart(self, product, quantity):

        ''' Adds _quantity_ of the given _product_ to the cart. Raises

        ValidationError if constraints are violated.'''

        try:

            product_item = rego.ProductItem.objects.get(

                cart=self.cart,

                product=product)

            old_quantity = product_item.quantity

        except ObjectDoesNotExist:

            old_quantity = 0

        self.set_quantity(product, old_quantity + quantity)

    def next_cart(self):

        self.cart.active = False

        self.cart.save()

import pytz

from decimal import Decimal

from registrasion import models as rego

from registrasion.controllers import discount

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class DiscountTestCase(RegistrationCartTestCase):

    @classmethod

    def add_discount_prod_1_includes_prod_2(

            cls,

            amount=Decimal(100),

            quantity=2,

            ):

        discount = rego.IncludedProductDiscount.objects.create(

            description="PROD_1 includes PROD_2 " + str(amount) + "%",

        )

        discount.save()

        discount.enabling_products.add(cls.PROD_1)

        discount.save()

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=cls.PROD_2,

            percentage=amount,

import datetime

import pytz

from decimal import Decimal

from django.core.exceptions import ValidationError

from registrasion import models as rego

from controller_helpers import TestingCartController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class InvoiceTestCase(RegistrationCartTestCase):

    def test_create_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        # That invoice should have a single line item

        line_items = rego.LineItem.objects.filter(invoice=invoice_1.invoice)

        self.assertEqual(1, len(line_items))

        # That invoice should have a value equal to cost of PROD_1

        self.assertEqual(self.PROD_1.price, invoice_1.invoice.value)

        # Adding item to cart should produce a new invoice

        current_cart.add_to_cart(self.PROD_2, 1)

        self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)

        # The old invoice should automatically be voided

        invoice_1_new = rego.Invoice.objects.get(pk=invoice_1.invoice.id)

        invoice_2_new = rego.Invoice.objects.get(pk=invoice_2.invoice.id)

        self.assertTrue(invoice_1_new.void)

        self.assertFalse(invoice_2_new.void)

        # Invoice should have two line items

        line_items = rego.LineItem.objects.filter(invoice=invoice_2.invoice)

        self.assertEqual(2, len(line_items))

        # Invoice should have a value equal to cost of PROD_1 and PROD_2

        self.assertEqual(

            self.PROD_1.price + self.PROD_2.price,

            invoice_2.invoice.value)

    def test_create_invoice_fails_if_cart_invalid(self):

        self.make_ceiling("Limit ceiling", limit=1)

        self.set_time(datetime.datetime(2015, 01, 01, tzinfo=UTC))

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_1, 1)

        self.add_timedelta(self.RESERVATION * 2)

        cart_2 = TestingCartController.for_user(self.USER_2)

        cart_2.add_to_cart(self.PROD_1, 1)

        # Now try to invoice the first user

        with self.assertRaises(ValidationError):

    def test_paying_invoice_makes_new_cart(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice.pay("A payment!", invoice.invoice.value)

        # This payment is for the correct amount invoice should be paid.

        self.assertTrue(invoice.invoice.paid)

        # Cart should not be active

        self.assertFalse(invoice.invoice.cart.active)

        # Asking for a cart should generate a new one

        new_cart = TestingCartController.for_user(self.USER_1)

        self.assertNotEqual(current_cart.cart, new_cart.cart)

    def test_invoice_includes_discounts(self):

        voucher = rego.Voucher.objects.create(

            recipient="Voucher recipient",

            code="VOUCHER",

            limit=1

        )

        discount = rego.VoucherDiscount.objects.create(

            description="VOUCHER RECIPIENT",

            voucher=voucher,

        )

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=self.PROD_1,

            percentage=Decimal(50),

            quantity=1

        )

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        # That invoice should have two line items

        line_items = rego.LineItem.objects.filter(invoice=invoice_1.invoice)

        self.assertEqual(2, len(line_items))

        # That invoice should have a value equal to 50% of the cost of PROD_1

        self.assertEqual(

            self.PROD_1.price * Decimal("0.5"),

            invoice_1.invoice.value)

    def test_zero_value_invoice_is_automatically_paid(self):

        voucher = rego.Voucher.objects.create(

            recipient="Voucher recipient",

            code="VOUCHER",

            limit=1

        )

        discount = rego.VoucherDiscount.objects.create(

            description="VOUCHER RECIPIENT",

            voucher=voucher,

        )

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=self.PROD_1,

            percentage=Decimal(100),

            quantity=1

        )

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        self.assertTrue(invoice_1.invoice.paid)

    def test_invoice_voids_self_if_cart_is_invalid(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        self.assertFalse(invoice_1.invoice.void)

        # Adding item to cart should produce a new invoice

        current_cart.add_to_cart(self.PROD_2, 1)

        self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)

        # Viewing invoice_1's invoice should show it as void

        self.assertTrue(invoice_1_new.invoice.void)

        # Viewing invoice_2's invoice should *not* show it as void

        self.assertFalse(invoice_2_new.invoice.void)

    def test_voiding_invoice_creates_new_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        self.assertFalse(invoice_1.invoice.void)

        invoice_1.void()

        self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)

    def test_cannot_pay_void_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice_1.void()

        with self.assertRaises(ValidationError):

            invoice_1.pay("Reference", invoice_1.invoice.value)

    def test_cannot_void_paid_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice_1.pay("Reference", invoice_1.invoice.value)

        with self.assertRaises(ValidationError):

            invoice_1.void()

    def test_cannot_generate_blank_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

    # TODO: test partially paid invoice cannot be void until payments

    # are refunded

    # TODO: test overpaid invoice results in credit note

    # TODO: test credit note generation more generally 

import pytz

from controller_helpers import TestingCartController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class RefundTestCase(RegistrationCartTestCase):

    def test_refund_marks_void_and_unpaid_and_cart_released(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice.pay("A Payment!", invoice.invoice.value)

        self.assertFalse(invoice.invoice.void)

        self.assertTrue(invoice.invoice.paid)

        self.assertFalse(invoice.invoice.cart.released)

        invoice.refund("A Refund!", invoice.invoice.value)

        self.assertTrue(invoice.invoice.void)

        self.assertFalse(invoice.invoice.paid)

        self.assertTrue(invoice.invoice.cart.released)

import datetime

import pytz

from decimal import Decimal

from django.core.exceptions import ValidationError

from django.db import IntegrityError

from registrasion import models as rego

from controller_helpers import TestingCartController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class VoucherTestCases(RegistrationCartTestCase):

    def test_apply_voucher(self):

        voucher = self.new_voucher()

        self.set_time(datetime.datetime(2015, 01, 01, tzinfo=UTC))

        cart_1 = TestingCartController.for_user(self.USER_1)

        cart_1.apply_voucher(voucher.code)

        self.assertIn(voucher, cart_1.cart.vouchers.all())

        # Second user should not be able to apply this voucher (it's exhausted)

        cart_2 = TestingCartController.for_user(self.USER_2)

        with self.assertRaises(ValidationError):

            cart_2.apply_voucher(voucher.code)

        # After the reservation duration

        # user 2 should be able to apply voucher

        # You can apply the code twice, but it will only add to the cart once.

        self.assertEqual(1, current_cart.cart.vouchers.count())

    def test_voucher_can_only_be_applied_once_across_multiple_carts(self):

        voucher = self.new_voucher(limit=2)

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        current_cart.next_cart()

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.apply_voucher(voucher.code)

        return current_cart

    def test_refund_releases_used_vouchers(self):

        voucher = self.new_voucher(limit=2)

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        current_cart.add_to_cart(self.PROD_1, 1)

        if not inv.invoice.paid:

            inv.pay("Hello!", inv.invoice.value)

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.apply_voucher(voucher.code)

        inv.refund("Hello!", inv.invoice.value)

        current_cart.apply_voucher(voucher.code)

    def test_fix_simple_errors_does_not_remove_limited_voucher(self):

        voucher = self.new_voucher(code="VOUCHER")

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        current_cart.fix_simple_errors()

        self.assertEqual(1, current_cart.cart.vouchers.count())