You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
336 lines
20 KiB
336 lines
20 KiB
from datetime import timedelta
|
|
|
|
from django.test import TestCase
|
|
from django.utils.timezone import now
|
|
|
|
from apps.payment.models import Discount
|
|
from project.tests.factories import CourseFactory, DiscountFactory, UserFactory, PackageFactory
|
|
|
|
|
|
class DiscountForCoursesModelTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
self.user = UserFactory.create()
|
|
|
|
def test_discounts_for_courses_without_user(self):
|
|
course_1 = CourseFactory.create()
|
|
course_2 = CourseFactory.create()
|
|
course_3 = CourseFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
self.assertEqual(all_curses_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})
|
|
self.assertEqual(discounts_for_courses[1], {'course': course_2.pk, 'max_discount': 50})
|
|
|
|
def test_greater_value_discount_without_user(self):
|
|
course = CourseFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
self.assertEqual(all_curses_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})
|
|
|
|
def test_exclude_personal_discounts_without_user(self):
|
|
user_1 = UserFactory.create()
|
|
course = CourseFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=user_1)
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
self.assertEqual(all_curses_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_course_and_all_courses(self):
|
|
course = CourseFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})
|
|
|
|
def test_personal_discounts(self):
|
|
course = CourseFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})
|
|
|
|
def test_personal_discounts_multiple_users(self):
|
|
user_1 = UserFactory()
|
|
course = CourseFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=user_1)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES,
|
|
client=self.user)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 50})
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=user_1)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_courses[0], {'course': course.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_course_without_user(self):
|
|
course_1 = CourseFactory.create()
|
|
course_2 = CourseFactory.create()
|
|
course_3 = CourseFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=60, course=course_3,
|
|
product=Discount.PRODUCT_ONE_COURSE)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=None, course=course_1)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': None})
|
|
self.assertEqual(len(discounts_for_courses), 1)
|
|
self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_course_with_multiple_users(self):
|
|
user_1 = UserFactory.create()
|
|
course_1 = CourseFactory.create()
|
|
course_2 = CourseFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=user_1)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=user_1)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, course=course_1,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, course=course_2,
|
|
product=Discount.PRODUCT_ONE_COURSE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_COURSES,
|
|
client=self.user)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=user_1,
|
|
course=course_1)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 10})
|
|
self.assertEqual(len(discounts_for_courses), 1)
|
|
self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts(user=self.user,
|
|
course=course_1)
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 50})
|
|
self.assertEqual(len(discounts_for_courses), 1)
|
|
self.assertEqual(discounts_for_courses[0], {'course': course_1.pk, 'max_discount': 30})
|
|
|
|
def test_not_active_discount(self):
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ALL_COURSES,
|
|
is_active=False)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_courses), 0)
|
|
|
|
def test_old_discount(self):
|
|
DiscountFactory.create(start=now() - timedelta(days=2), end=now() - timedelta(days=1), value=60,
|
|
product=Discount.PRODUCT_ALL_COURSES)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_courses), 0)
|
|
|
|
def test_discount_from_the_future(self):
|
|
DiscountFactory.create(start=now() + timedelta(days=2), end=now() + timedelta(days=3), value=60,
|
|
product=Discount.PRODUCT_ALL_COURSES)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_COURSES)
|
|
|
|
all_curses_discounts, discounts_for_courses = Discount.objects.get_courses_discounts()
|
|
|
|
self.assertEqual(all_curses_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_courses), 0)
|
|
|
|
|
|
class DiscountForPackagesModelTestCase(TestCase):
|
|
|
|
def setUp(self):
|
|
self.user = UserFactory.create()
|
|
|
|
def test_discounts_for_packages_without_user(self):
|
|
package_1 = PackageFactory.create()
|
|
package_2 = PackageFactory.create()
|
|
package_3 = PackageFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
self.assertEqual(all_packages_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})
|
|
self.assertEqual(discounts_for_packages[1], {'package': package_2.pk, 'max_discount': 50})
|
|
|
|
def test_greater_value_discount_without_user(self):
|
|
package = PackageFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
self.assertEqual(all_packages_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})
|
|
|
|
def test_exclude_personal_discounts_without_user(self):
|
|
user_1 = UserFactory.create()
|
|
package = PackageFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
self.assertEqual(all_packages_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_package_and_all_packages(self):
|
|
package = PackageFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})
|
|
|
|
def test_personal_discounts(self):
|
|
package = PackageFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})
|
|
|
|
def test_personal_discounts_multiple_users(self):
|
|
user_1 = UserFactory()
|
|
package = PackageFactory.create()
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES,
|
|
client=self.user)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 10})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 50})
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=user_1)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': None})
|
|
self.assertEqual(discounts_for_packages[0], {'package': package.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_package_without_user(self):
|
|
package_1 = PackageFactory.create()
|
|
package_2 = PackageFactory.create()
|
|
package_3 = PackageFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=60, package=package_3,
|
|
product=Discount.PRODUCT_ONE_PACKAGE)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=None,
|
|
package=package_1)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': None})
|
|
self.assertEqual(len(discounts_for_packages), 1)
|
|
self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})
|
|
|
|
def test_discount_for_one_package_with_multiple_users(self):
|
|
user_1 = UserFactory.create()
|
|
package_1 = PackageFactory.create()
|
|
package_2 = PackageFactory.create()
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=10, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=user_1)
|
|
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=30, package=package_1,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, package=package_2,
|
|
product=Discount.PRODUCT_ONE_PACKAGE, client=self.user)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=50, product=Discount.PRODUCT_ALL_PACKAGES,
|
|
client=self.user)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=user_1,
|
|
package=package_1)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 10})
|
|
self.assertEqual(len(discounts_for_packages), 1)
|
|
self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts(user=self.user,
|
|
package=package_1)
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 50})
|
|
self.assertEqual(len(discounts_for_packages), 1)
|
|
self.assertEqual(discounts_for_packages[0], {'package': package_1.pk, 'max_discount': 30})
|
|
|
|
def test_not_active_discount(self):
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=60, product=Discount.PRODUCT_ALL_PACKAGES,
|
|
is_active=False)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_packages), 0)
|
|
|
|
def test_old_discount(self):
|
|
DiscountFactory.create(start=now() - timedelta(days=2), end=now() - timedelta(days=1), value=60,
|
|
product=Discount.PRODUCT_ALL_PACKAGES)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_packages), 0)
|
|
|
|
def test_discount_from_the_future(self):
|
|
DiscountFactory.create(start=now() + timedelta(days=2), end=now() + timedelta(days=3), value=60,
|
|
product=Discount.PRODUCT_ALL_PACKAGES)
|
|
DiscountFactory.create(end=now() + timedelta(days=5), value=40, product=Discount.PRODUCT_ALL_PACKAGES)
|
|
|
|
all_packages_discounts, discounts_for_packages = Discount.objects.get_packages_discounts()
|
|
|
|
self.assertEqual(all_packages_discounts, {'max_discount': 40})
|
|
self.assertEqual(len(discounts_for_packages), 0)
|
|
|