Example #1
0
    def test_calculate_balance(self):
        available_calendar = CalendarFactory(
            activity__organizer=self.organizer)
        available_orders = OrderFactory.create_batch(
            size=3,
            calendar=available_calendar,
            status='approved',
            fee=0,
            amount=factory.Iterator([20000, 30000]))

        unavailable_calendar = CalendarFactory(
            activity__organizer=self.organizer)
        unavailable_orders = OrderFactory.create_batch(
            size=4,
            calendar=unavailable_calendar,
            status='approved',
            fee=0,
            amount=factory.Iterator([20000, 30000]))

        status = [*['available'] * 3, *['unavailable'] * 4]

        BalanceLogFactory.create_batch(
            size=7,
            order=factory.Iterator([*available_orders, *unavailable_orders]),
            organizer=self.organizer,
            status=factory.Iterator(status))

        task = CalculateOrganizerBalanceTask()
        task.delay(organizer_ids=[self.organizer.id])

        balance = Balance.objects.get(id=self.organizer.balance.id)
        self.assertEqual(balance.available, 70000)
        self.assertEqual(balance.unavailable, 100000)
Example #2
0
class OrderModelTest(APITestCase):
    """
    Class for test the model Order
    """
    def setUp(self):
        # Arrangement
        self.student = StudentFactory()
        self.order = OrderFactory(amount=500, student=self.student)

    def test_get_total(self):
        """
        Test method get_total without coupon
        """

        self.assertEqual(self.order.get_total(student=self.student),
                         self.order.amount)

    def test_get_total_with_coupon_not_used(self):
        """
        Test method get_total with a coupon not used
        """

        # Arrangement
        coupon_type = mommy.make(CouponType, name='referred', amount=100)
        redeem = mommy.make(Redeem,
                            student=self.student,
                            coupon__coupon_type=coupon_type)
        self.order.coupon = redeem.coupon
        self.order.save()

        self.assertEqual(self.order.get_total(student=self.student),
                         self.order.amount)

    def test_get_total_with_coupon_used(self):
        """
        Test method get_total with a coupon used
        """

        # Arrangement
        coupon_type = mommy.make(CouponType, name='referred', amount=100)
        redeem = mommy.make(Redeem,
                            student=self.student,
                            coupon__coupon_type=coupon_type,
                            used=True)
        self.order.coupon = redeem.coupon
        self.order.save()
        total = self.order.amount - redeem.coupon.coupon_type.amount

        self.assertEqual(self.order.get_total(student=self.student), total)

    def test_get_total_error(self):
        """
        Test case when total is called without student
        """

        with self.assertRaisesRegex(TypeError, 'get_total().*student'):
            self.order.get_total()
Example #3
0
    def test_having_an_free_activity(self, delay):
        """
        Test case should create the coupon
        because the student has a free activity
        """

        # Arrangement
        OrderFactory(student=self.another_student, calendar__is_free=True)

        # Counter
        coupon_counter = Coupon.objects.count()
        redeem_counter = Redeem.objects.count()

        # Call the task
        task = ReferrerCouponTask()
        task.delay(student_id=self.another_student.id, order_id=self.order.id)

        self.assertEqual(Coupon.objects.count(), coupon_counter + 1)
        self.assertTrue(
            Coupon.objects.filter(coupon_type=self.coupon_type).exists())
        self.assertEqual(Redeem.objects.count(), redeem_counter + 1)
        self.assertTrue(
            Redeem.objects.filter(
                student=self.student,
                coupon__coupon_type=self.coupon_type).exists())
Example #4
0
    def test_send_pse_order_approved(self, send_mail):
        """
        Test task send the email successfully when:
        - the order is approved
        - the payment method is pse
        """

        payment = PaymentFactory(payment_type='PSE')
        order = OrderFactory(status=Order.ORDER_APPROVED_STATUS, payment=payment)
        email = order.calendar.activity.organizer.user.email
        assistants = AssistantFactory.create_batch(1, order=order)

        send_mail.return_value = [{
            'email': email,
            'status': 'sent',
            'reject_reason': None
        }]

        task = SendNewEnrollmentEmailTask()
        task_id = task.delay(order.id)

        context = {
            **self.get_context_data(order, assistants),
            'status': 'Aprobada',
            'payment_type': 'PSE',
            'card_type': dict(Payment.CARD_TYPE)[payment.card_type],
            'coupon_amount': None,
        }

        self.assertTrue(EmailTaskRecord.objects.filter(
            task_id=task_id,
            to=email,
            status='sent',
            data=context,
            template_name='payments/email/new_enrollment.html').exists())
Example #5
0
    def create_orders(self):
        self.stdout.write('Creando orders')
        orders = list()
        fee = self.create_fee()
        for calendar in self.calendars:
            size = self.get_quantity()
            quantity = size
            if calendar.available_capacity < 1:
                continue
            orders.append(
                OrderFactory.create_batch(size,
                                          calendar=calendar,
                                          student=factory.Iterator(
                                              Student.objects.all(),
                                              cycle=True),
                                          fee=fee,
                                          fee_detail={},
                                          quantity=quantity))

        for o in self.flat_list(orders):
            fee_detail = Order.get_fee_detail(o, False, o.payment, None)
            fee = fee_detail.get('total_fee')
            o.fee, o.fee_detail = o.fee, fee_detail
            o.save()

        return self.flat_list(orders)
Example #6
0
 def setUp(self):
     super(ListAndCreateOrganizerMessageViewTest, self).setUp()
     self.url = reverse('messages:list_and_create')
     self.calendar = CalendarFactory(activity__organizer=self.organizer)
     self.orders = OrderFactory.create_batch(3, calendar=self.calendar,
                                             status=Order.ORDER_APPROVED_STATUS)
     self.organizer_messages = OrganizerMessageFactory.create_batch(3, organizer=self.organizer,
                                                                    calendar=self.calendar)
     self.organizer_message_relation = OrganizerMessageStudentRelationFactory(
         organizer_message=self.organizer_messages[0],
         student=self.student,
     )
Example #7
0
    def test_balance_not_yet_available(self):
        calendar = CalendarFactory(activity__organizer=self.organizer,
                                   initial_date=now().date())
        order = OrderFactory(calendar=calendar)
        balance_log = BalanceLogFactory(organizer=self.organizer, order=order)

        task = BalanceLogToAvailableTask()
        result = task.delay()

        self.assertEqual(
            BalanceLog.objects.get(id=balance_log.id).status, 'unavailable')
        self.assertEqual(result.result, [])
Example #8
0
    def test_get_list_orders_of_current_user_ok(self):
        order_objs = [
            OrderFactory(
                user=self.authenticated_user,
                status=factories.FuzzyChoice(
                    OrderStatusesEnum.values()).fuzz(),
            ) for _ in range(30)
        ]

        resp = self.get_json()
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(len(order_objs), resp.data['count'])
Example #9
0
    def test_balance_log_available(self):
        last_week = (now() - timedelta(days=5)).date()
        calendar = CalendarFactory(activity__organizer=self.organizer,
                                   initial_date=last_week)
        order = OrderFactory(calendar=calendar)
        balance_log = BalanceLogFactory(organizer=self.organizer, order=order)

        task = BalanceLogToAvailableTask()
        result = task.delay()

        self.assertEqual(
            BalanceLog.objects.get(id=balance_log.id).status, 'available')
        self.assertEqual(result.result, [self.organizer.id])
Example #10
0
 def setUp(self):
     self.activity = ActivityFactory()
     self.author = mommy.make(Student)
     self.order = OrderFactory(status=Order.ORDER_APPROVED_STATUS,
                               calendar__activity=self.activity,
                               calendar__initial_date=now() -
                               timedelta(days=3),
                               student=self.author)
     self.data = {
         'rating': 5,
         'activity': self.activity.id,
     }
     self.context = self.get_context()
Example #11
0
    def setUp(self):
        self.organizer = OrganizerFactory()
        self.calendar = CalendarFactory(activity__organizer=self.organizer)
        self.organizer_message = OrganizerMessageFactory(
            calendar=self.calendar)
        self.orders = OrderFactory.create_batch(
            size=3, calendar=self.calendar, status=Order.ORDER_APPROVED_STATUS)

        self.assistants = []
        for order in self.orders:
            self.assistants.append(
                AssistantFactory(order=order,
                                 email=order.student.user.email,
                                 enrolled=True))
Example #12
0
    def test_put_cancel_an_order_ok(self):
        """
        Test for API PUT /api/v1/orders/me/{order_id}/cancel/
        """
        # Create an order for test
        waiting_order_obj = OrderFactory(
            user=self.authenticated_user,
            status=OrderStatusesEnum.WAITING.value,
        )

        # Cancel an order
        waiting_order_id = waiting_order_obj.id
        resp = self.put_json(data={}, fragment=f'{waiting_order_id}/cancel/')
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(resp.data.get('order_id'), waiting_order_id)
Example #13
0
    def test_send_mail_failed(self, send_mail):
        """
        Test the task when the send_mail fails
        """
        payment = PaymentFactory(payment_type='CC', card_type='visa')
        order = OrderFactory(status=Order.ORDER_APPROVED_STATUS, payment=payment)

        send_mail.side_effect = Exception('Connection failed')

        task = SendPaymentEmailTask()
        task_id = task.delay(order.id)

        self.assertTrue(EmailTaskRecord.objects.filter(
            task_id=task_id,
            to=order.student.user.email,
            status='error',
            reject_reason='Connection failed').exists())
Example #14
0
    def test_put_pay_an_order_ok(self):
        """
        API PUT /api/v1/orders/me/{order_id}/payment/
        """
        can_pay_statuses = [
            OrderStatusesEnum.IN_PROGRESS.value,
            OrderStatusesEnum.SHIPPING.value,
        ]

        for order_status in can_pay_statuses:
            order_obj = OrderFactory(
                user=self.authenticated_user,
                status=order_status,
            )

            # Cancel an order
            order_id = order_obj.id
            resp = self.put_json(data={}, fragment=f'{order_id}/payment/')
            self.assertEqual(resp.status_code, status.HTTP_200_OK)
            self.assertEqual(resp.data.get('order_id'), order_id)
Example #15
0
    def test_send_pse_order_with_coupon_declined(self, send_mail):
        """
        Test task send the email successfully when:
        - the order is declined
        - the payment method is pse
        - the order has a coupon
        """

        student = StudentFactory()
        redeem = RedeemFactory(student=student, used=True)
        payment = PaymentFactory(payment_type='PSE')
        order = OrderFactory(status=Order.ORDER_DECLINED_STATUS, payment=payment,
                             student=student, coupon=redeem.coupon)
        email = order.student.user.email
        assistants = AssistantFactory.create_batch(1, order=order)
        transaction_error = 'ERROR'

        send_mail.return_value = [{
            'email': email,
            'status': 'sent',
            'reject_reason': None
        }]

        task = SendPaymentEmailTask()
        task_id = task.delay(order.id, transaction_error=transaction_error)

        context = {
            **self.get_context_data(order, assistants),
            'status': 'Declinada',
            'payment_type': 'PSE',
            'card_type': dict(Payment.CARD_TYPE)[payment.card_type],
            'coupon_amount': redeem.coupon.coupon_type.amount,
            'error': transaction_error,
        }

        self.assertTrue(EmailTaskRecord.objects.filter(
            task_id=task_id,
            to=email,
            status='sent',
            data=context,
            template_name='payments/email/payment_declined.html').exists())
Example #16
0
    def _seed_orders(cls) -> None:
        """
        Seeding orders
        """
        order_status = [
            OrderStatusesEnum.SHIPPING.value,
            OrderStatusesEnum.WAITING.value,
            OrderStatusesEnum.CANCELED.value,
            OrderStatusesEnum.PAID.value,
            OrderStatusesEnum.IN_PROGRESS.value,
        ]

        for _ in range(50):
            order_obj = OrderFactory(
                user=FuzzyChoice(cls.users).fuzz(),
                status=FuzzyChoice(order_status).fuzz(),
            )
            cls.orders.append(order_obj)

            for _ in range(FuzzyInteger(5, 10).fuzz()):
                OrderItemFactory(order=order_obj,
                                 product=FuzzyChoice(cls.products).fuzz())
Example #17
0
    def test_send_creditcard_with_coupon_order_approved(self, send_mail):
        """
        Test task send the email successfully when:
        - the order is approved
        - the payment method is credit card
        - the order has a coupon
        """

        student = StudentFactory()
        redeem = RedeemFactory(student=student, used=True)
        payment = PaymentFactory(payment_type='CC', card_type='visa')
        order = OrderFactory(status=Order.ORDER_APPROVED_STATUS, payment=payment,
                             student=student, coupon=redeem.coupon)
        email = order.student.user.email
        assistants = AssistantFactory.create_batch(1, order=order)

        send_mail.return_value = [{
            'email': email,
            'status': 'sent',
            'reject_reason': None
        }]

        task = SendPaymentEmailTask()
        task_id = task.delay(order.id)

        context = {
            **self.get_context_data(order, assistants),
            'status': 'Aprobada',
            'payment_type': 'Crédito',
            'card_type': 'VISA',
            'coupon_amount': redeem.coupon.coupon_type.amount,
        }

        self.assertTrue(EmailTaskRecord.objects.filter(
            task_id=task_id,
            to=email,
            status='sent',
            data=context,
            template_name='payments/email/payment_approved.html').exists())
Example #18
0
    def test_put_cancel_an_order_bad_request(self):
        """
        If an user is not `Waiting` status. We cannot cancel.

        API PUT /api/v1/orders/me/{order_id}/cancel/
        """
        statuses = OrderStatusesEnum.values()
        statuses.remove(OrderStatusesEnum.WAITING.value)

        # Test for all order status except WAITING
        for order_status in statuses:
            not_waiting_order_obj = OrderFactory(
                user=self.authenticated_user,
                status=order_status,
            )

            # Cancel an order
            not_waiting_order_id = not_waiting_order_obj.id
            resp = self.put_json(data={},
                                 fragment=f'{not_waiting_order_id}/cancel/')
            self.assertEqual(resp.status_code, status.HTTP_404_NOT_FOUND)
            self.has_valid_custom_error_response(resp)
Example #19
0
    def test_send_creditcard_order_without_coupon_declined(self, send_mail):
        """
        Test task send the email successfully when:
        - the order is declined
        - the payment method is credit card
        - the order doesn't have a coupon
        """

        payment = PaymentFactory(payment_type='CC', card_type='visa')
        order = OrderFactory(status=Order.ORDER_DECLINED_STATUS, payment=payment)
        email = order.student.user.email
        assistants = AssistantFactory.create_batch(1, order=order)
        transaction_error = 'ERROR'

        send_mail.return_value = [{
            'email': email,
            'status': 'sent',
            'reject_reason': None
        }]

        task = SendPaymentEmailTask()
        task_id = task.delay(order.id, transaction_error=transaction_error)

        context = {
            **self.get_context_data(order, assistants),
            'status': 'Declinada',
            'payment_type': 'Crédito',
            'card_type': 'VISA',
            'coupon_amount': None,
            'error': transaction_error,
        }

        self.assertTrue(EmailTaskRecord.objects.filter(
            task_id=task_id,
            to=email,
            status='sent',
            data=context,
            template_name='payments/email/payment_declined.html').exists())
Example #20
0
    def test_put_pay_an_order_bad_request(self):
        """
        API PUT /api/v1/orders/me/{order_id}/payment/
        """
        can_not_pay_statuses = [
            OrderStatusesEnum.SHOPPING.value,
            OrderStatusesEnum.WAITING.value,
            OrderStatusesEnum.CANCELED.value,
            OrderStatusesEnum.PAID.value,
        ]

        for order_status in can_not_pay_statuses:
            # Create order
            order_obj = OrderFactory(
                user=self.authenticated_user,
                status=order_status,
            )

            # Pay an order
            order_id = order_obj.id
            resp = self.put_json(data={}, fragment=f'{order_id}/payment/')
            self.assertEqual(resp.status_code, status.HTTP_404_NOT_FOUND)
            self.has_valid_custom_error_response(resp)
Example #21
0
    def test_with_an_payed_activity(self):
        """
        Test case when shouldn't create a referrer coupon
        because the student already has a payed activity
        """

        # Arrangement
        OrderFactory(student=self.another_student)

        # Counter
        coupon_counter = Coupon.objects.count()
        redeem_counter = Redeem.objects.count()

        # Call the task
        task = ReferrerCouponTask()
        task.delay(student_id=self.another_student.id, order_id=self.order.id)

        self.assertEqual(Coupon.objects.count(), coupon_counter)
        self.assertEqual(Redeem.objects.count(), redeem_counter)
        self.assertFalse(
            Redeem.objects.filter(
                student=self.student,
                coupon__coupon_type=self.coupon_type).exists())
Example #22
0
 def setUp(self):
     self.calendar = CalendarFactory()
     self.order = OrderFactory(calendar=self.calendar, status='approved')
Example #23
0
 def setUp(self):
     self.calendar = CalendarFactory()
     self.order = OrderFactory(calendar=self.calendar, status=Order.ORDER_APPROVED_STATUS)
     self.assistants = AssistantFactory.create_batch(2, order=self.order)
Example #24
0
 def setUp(self):
     self.payu_callback_url = reverse('payments:notification')
     self.payment = PaymentFactory()
     self.order = OrderFactory(payment=self.payment,
                               status=Order.ORDER_PENDING_STATUS)
 def setUp(self):
     self.factory = RequestFactory()
     self.order = OrderFactory()
Example #26
0
 def setUp(self):
     # Arrangement
     self.student = StudentFactory()
     self.order = OrderFactory(amount=500, student=self.student)
Example #27
0
    def setUp(self):
        # Calling the super (initialization)
        super(ReviewAPITest, self).setUp()

        # Objects needed
        self.activity = ActivityFactory(organizer=self.organizer,
                                        published=True)
        self.calendar = CalendarFactory(
            activity=self.activity,
            initial_date=(now() - timedelta(days=2)).date())
        self.order = OrderFactory(student=self.student,
                                  calendar=self.calendar,
                                  status=Order.ORDER_APPROVED_STATUS)
        self.post = {'rating': 4, 'comment': 'First comment!'}
        self.read_review_post = {'rating': 4, 'comment': 'Im a read review!'}
        self.unread_review_post = {
            'rating': 4,
            'comment': 'Im an unread review!'
        }
        self.put = {'rating': 2, 'reply': 'Thank you!'}
        self.review = mommy.make(Review,
                                 author=self.student,
                                 activity=self.activity,
                                 **self.post)
        self.read_review = mommy.make(Review,
                                      author=self.student,
                                      activity=self.activity,
                                      read=True,
                                      **self.read_review_post)
        self.unread_review = mommy.make(Review,
                                        author=self.student,
                                        activity=self.activity,
                                        read=False,
                                        **self.unread_review_post)

        # URLs
        self.list_by_organizer_url = reverse(
            'reviews:list_by_organizer',
            kwargs={'organizer_pk': self.organizer.id})
        self.list_by_student_url = reverse(
            'reviews:list_by_student', kwargs={'student_pk': self.student.id})
        self.create_url = reverse('reviews:create',
                                  kwargs={'activity_pk': self.activity.id})
        self.retrieve_update_delete_url = reverse(
            'reviews:reply', kwargs={'pk': self.review.id})
        self.report_url = reverse('reviews:report',
                                  kwargs={'pk': self.review.id})
        self.read_url = reverse('reviews:read', kwargs={'pk': self.review.id})

        # Counters
        self.review_count = Review.objects.count()
        self.activity_reviews = self.activity.reviews.count()

        # Set permissions
        add_review = Permission.objects.get_by_natural_key(
            'add_review', 'reviews', 'review')
        add_review.user_set.add(self.student.user, self.another_student.user)
        change_review = Permission.objects.get_by_natural_key(
            'change_review', 'reviews', 'review')
        change_review.user_set.add(self.organizer.user,
                                   self.another_organizer.user)
        assign_perm('reviews.reply_review',
                    user_or_group=self.organizer.user,
                    obj=self.review)
        assign_perm('reviews.report_review',
                    user_or_group=self.organizer.user,
                    obj=self.review)
        assign_perm('reviews.read_review',
                    user_or_group=self.organizer.user,
                    obj=self.review)
Example #28
0
 def setUp(self):
     self.order = OrderFactory(amount=500,
                               status=Order.ORDER_APPROVED_STATUS)
     self.assistants = mommy.make(Assistant, order=self.order, _quantity=2)
Example #29
0
    def setUp(self):
        super(OrdersAPITest, self).setUp()

        # Create Activities objects
        self.activity = ActivityFactory(organizer=self.organizer,
                                        published=True)
        self.other_activity = ActivityFactory(organizer=self.organizer,
                                              published=True)
        self.active_activity = ActivityFactory(published=True)
        self.inactive_activity = ActivityFactory()

        # Create Calendards objects
        self.calendar = mommy.make(Calendar, activity=self.activity)
        self.other_calendar = mommy.make(Calendar,
                                         activity=self.other_activity)
        self.free_calendar = mommy.make(Calendar,
                                        is_free=True,
                                        activity=self.active_activity,
                                        available_capacity=10)
        self.inactive_calendar = mommy.make(Calendar,
                                            activity=self.inactive_activity)
        self.full_calendar = mommy.make(Calendar,
                                        activity=self.active_activity,
                                        available_capacity=0)
        self.closed_enroll_calendar = mommy.make(Calendar,
                                                 activity=self.active_activity,
                                                 enroll_open=False)

        # Create Orders objects
        OrderFactory.create_batch(student=self.student, size=2)
        OrderFactory.create_batch(calendar=self.calendar, size=2)
        OrderFactory.create_batch(calendar=self.other_calendar, size=2)
        self.order = OrderFactory(student=self.student)
        self.another_other = OrderFactory()

        # URLs
        self.orders_by_activity_url = reverse(
            'orders:create_or_list_by_activity',
            kwargs={'activity_pk': self.activity.id})

        self.orders_by_student_url = reverse(
            'orders:list_by_student', kwargs={'student_pk': self.student.id})

        self.orders_by_organizer_url = reverse(
            'orders:list_by_organizer',
            kwargs={'organizer_pk': self.organizer.id})

        self.order_retrieve_url = reverse('orders:retrieve',
                                          kwargs={'order_pk': self.order.id})

        self.another_order_retrieve_url = reverse(
            'orders:retrieve', kwargs={'order_pk': self.another_other.id})

        self.create_order_url = reverse(
            'orders:create_or_list_by_activity',
            kwargs={'activity_pk': self.active_activity.id})

        self.create_inactive_activity_order_url = reverse(
            'orders:create_or_list_by_activity',
            kwargs={'activity_pk': self.inactive_activity.id})

        # Set permissions
        permission = Permission.objects.get_by_natural_key(
            'add_order', 'orders', 'order')
        permission.user_set.add(self.student.user)

        # counts
        self.orders_count = Order.objects.all().count()
        self.student_orders_count = Order.objects.filter(
            student=self.student).count()
        self.activity_orders_count = Order.objects.filter(
            calendar=self.calendar).count()
        self.organizer_orders_count = Order.objects. \
            filter(calendar__activity__organizer=self.organizer).count()