import datetime

import pytz

from decimal import Decimal

from django.contrib.auth.models import User

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.test import TestCase

from registrasion import models as rego

from registrasion.controllers.product import ProductController

from patch_datetime import SetTimeMixin

UTC = pytz.timezone('UTC')

class RegistrationCartTestCase(SetTimeMixin, TestCase):

    def setUp(self):

        super(RegistrationCartTestCase, self).setUp()

    @classmethod

    def setUpTestData(cls):

        cls.USER_1 = User.objects.create_user(

            username='testuser',

            email='test@example.com',

            password='top_secret')

        cls.USER_2 = User.objects.create_user(

            username='testuser2',

            email='test2@example.com',

            password='top_secret')

        cls.RESERVATION = datetime.timedelta(hours=1)

        cls.categories = []

        for i in xrange(2):

            cat = rego.Category.objects.create(

                name="Category " + str(i + 1),

                description="This is a test category",

                order=i,

                render_type=rego.Category.RENDER_TYPE_RADIO,

                required=False,

            )

            cat.save()

            cls.categories.append(cat)

        cls.CAT_1 = cls.categories[0]

        cls.CAT_2 = cls.categories[1]

        cls.products = []

        for i in xrange(4):

            prod = rego.Product.objects.create(

                name="Product " + str(i + 1),

                description="This is a test product.",

                category=cls.categories[i / 2],  # 2 products per category

                price=Decimal("10.00"),

                reservation_duration=cls.RESERVATION,

                limit_per_user=10,

import datetime

import pytz

from django.core.exceptions import ValidationError

from test_cart import RegistrationCartTestCase

from registrasion import models as rego

UTC = pytz.timezone('UTC')

class CeilingsTestCases(RegistrationCartTestCase):

    def test_add_to_cart_ceiling_limit(self):

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

        self.__add_to_cart_test()

    def test_add_to_cart_ceiling_category_limit(self):

        self.make_category_ceiling("Limit ceiling", limit=9)

        self.__add_to_cart_test()

    def __add_to_cart_test(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # User should not be able to add 10 of PROD_1 to the current cart

        # because it is affected by limit_ceiling

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_2, 10)

        # User should be able to add 5 of PROD_1 to the current cart

        current_cart.add_to_cart(self.PROD_1, 5)

        # User should not be able to add 6 of PROD_2 to the current cart

        # because it is affected by CEIL_1

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_2, 6)

        # User should be able to add 5 of PROD_2 to the current cart

        current_cart.add_to_cart(self.PROD_2, 4)

    def test_add_to_cart_ceiling_date_range(self):

        self.make_ceiling(

            "date range ceiling",

            start_time=datetime.datetime(2015, 01, 01, tzinfo=UTC),

            end_time=datetime.datetime(2015, 02, 01, tzinfo=UTC))

        current_cart = TestingCartController.for_user(self.USER_1)

        # User should not be able to add whilst we're before start_time

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

        with self.assertRaises(ValidationError):

import pytz

from django.core.exceptions import ValidationError

from registrasion import models as rego

from registrasion.controllers.category import CategoryController

from registrasion.controllers.product import ProductController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class EnablingConditionTestCases(RegistrationCartTestCase):

    @classmethod

    def add_product_enabling_condition(cls, mandatory=False):

        ''' Adds a product enabling condition: adding PROD_1 to a cart is

        predicated on adding PROD_2 beforehand. '''

        enabling_condition = rego.ProductEnablingCondition.objects.create(

            description="Product condition",

            mandatory=mandatory,

        )

        enabling_condition.save()

        enabling_condition.products.add(cls.PROD_1)

        enabling_condition.enabling_products.add(cls.PROD_2)

        enabling_condition.save()

    @classmethod

    def add_product_enabling_condition_on_category(cls, mandatory=False):

        ''' Adds a product enabling condition that operates on a category:

        adding an item from CAT_1 is predicated on adding PROD_3 beforehand '''

        enabling_condition = rego.ProductEnablingCondition.objects.create(

            description="Product condition",

            mandatory=mandatory,

        )

        enabling_condition.save()

        enabling_condition.categories.add(cls.CAT_1)

        enabling_condition.enabling_products.add(cls.PROD_3)

        enabling_condition.save()

    def add_category_enabling_condition(cls, mandatory=False):

        ''' Adds a category enabling condition: adding PROD_1 to a cart is

        predicated on adding an item from CAT_2 beforehand.'''

        enabling_condition = rego.CategoryEnablingCondition.objects.create(

            description="Category condition",

            mandatory=mandatory,

            enabling_category=cls.CAT_2,

        )

        enabling_condition.save()

        enabling_condition.products.add(cls.PROD_1)

        enabling_condition.save()

    def test_product_enabling_condition_enables_product(self):

import datetime

import pytz

from decimal import Decimal

from django.core.exceptions import ValidationError

from registrasion import models as rego

from registrasion.controllers.invoice import InvoiceController

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)

        invoice_1 = InvoiceController.for_cart(current_cart.cart)

        # 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)

        invoice_2 = InvoiceController.for_cart(current_cart.cart)

        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)

        # Viewing invoice_1's invoice should show it as void

        invoice_1_new = InvoiceController(invoice_1.invoice)

        self.assertTrue(invoice_1_new.invoice.void)

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

        invoice_2_new = InvoiceController(invoice_2.invoice)

        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)

        invoice_1 = InvoiceController.for_cart(current_cart.cart)

        self.assertFalse(invoice_1.invoice.void)

        invoice_1.void()

        invoice_2 = InvoiceController.for_cart(current_cart.cart)

        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 = InvoiceController.for_cart(current_cart.cart)

        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 = InvoiceController.for_cart(current_cart.cart)

        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):

import pytz

from registrasion.controllers.invoice import InvoiceController

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 = InvoiceController.for_cart(current_cart.cart)

        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 registrasion.controllers.invoice import InvoiceController

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

        self.add_timedelta(rego.Voucher.RESERVATION_DURATION * 2)

        cart_2.apply_voucher(voucher.code)

        cart_2.next_cart()

        # After the reservation duration, even though the voucher has applied,

        # it exceeds the number of vouchers available.

        self.add_timedelta(rego.Voucher.RESERVATION_DURATION * 2)

        with self.assertRaises(ValidationError):

            cart_1.validate_cart()

    def test_fix_simple_errors_resolves_unavailable_voucher(self):

        self.test_apply_voucher()

        # User has an exhausted voucher leftover from test_apply_voucher

        cart_1 = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            cart_1.validate_cart()

        cart_1.fix_simple_errors()

        # This should work now.

        cart_1.validate_cart()