def to_dict(self): """ Get a serialized representation of the Order and any attached Lines """ data = serialize_model_object(self) data['lines'] = [serialize_model_object(line) for line in self.line_set.all()] return data
def test_save_and_log(self): """ Tests that FinancialAid.save_and_log() creates an audit record with the correct information. """ with mute_signals(post_save): profile = ProfileFactory.create() acting_user = profile.user financial_aid = FinancialAidFactory.create() original_before_json = serialize_model_object(financial_aid) # Make sure audit object is created assert FinancialAidAudit.objects.count() == 0 financial_aid.status = FinancialAidStatus.AUTO_APPROVED financial_aid.save_and_log(acting_user) assert FinancialAidAudit.objects.count() == 1 # Make sure the before and after data are correct financial_aid.refresh_from_db() original_after_json = serialize_model_object(financial_aid) financial_aid_audit = FinancialAidAudit.objects.first() before_json = financial_aid_audit.data_before after_json = financial_aid_audit.data_after for field, value in before_json.items(): # Data before if isinstance(value, float): # JSON serialization of FloatField is precise, so we need to do almost equal self.assertAlmostEqual(value, original_before_json[field]) else: assert value == original_before_json[field] for field, value in after_json.items(): # Data after if isinstance(value, float): # JSON serialization of FloatField is precise, so we need to do almost equal self.assertAlmostEqual(value, original_after_json[field]) else: assert value == original_after_json[field]
def test_to_dict(self): """ Test Order.to_dict() """ order = OrderFactory.create() lines = [LineFactory.create(order=order) for _ in range(5)] data = order.to_dict() lines_data = data.pop('lines') assert serialize_model_object(order) == data assert lines_data == [serialize_model_object(line) for line in lines]
def test_datetime(self): """ Test that a model with a datetime and date field is handled correctly """ financial_aid = FinancialAidFactory.create(justification=None) assert serialize_model_object(financial_aid) == { 'country_of_income': financial_aid.country_of_income, 'country_of_residence': financial_aid.country_of_residence, 'created_on': format_as_iso8601(financial_aid.created_on), 'date_documents_sent': financial_aid.date_documents_sent.isoformat(), 'date_exchange_rate': format_as_iso8601(financial_aid.date_exchange_rate), 'id': financial_aid.id, 'income_usd': financial_aid.income_usd, 'justification': None, 'original_currency': financial_aid.original_currency, 'original_income': financial_aid.original_income, 'status': financial_aid.status, 'tier_program': financial_aid.tier_program.id, 'updated_on': format_as_iso8601(financial_aid.updated_on), 'user': financial_aid.user.id, }
def test_jsonfield(self): """ Test a model with a JSONField is handled correctly """ with override_settings(CYBERSOURCE_SECURITY_KEY='asdf'): receipt = ReceiptFactory.create() assert serialize_model_object(receipt) == { 'created_at': format_as_iso8601(receipt.created_at), 'data': receipt.data, 'id': receipt.id, 'modified_at': format_as_iso8601(receipt.modified_at), 'order': receipt.order.id, }
def test_create_user_coupon(self, already_exists): """ Test happy case for creating a UserCoupon """ previous_modified = self.coupon.user_coupon_qset( self.user).first().updated_on if not already_exists: # Won't change anything if it already exists UserCoupon.objects.all().delete() data = { 'username': get_social_username(self.user), } with patch('ecommerce.views.is_coupon_redeemable', autospec=True) as _is_redeemable_mock: _is_redeemable_mock.return_value = True resp = self.client.post( reverse('coupon-user-create', kwargs={'code': self.coupon.coupon_code}), data=data, format='json', ) _is_redeemable_mock.assert_called_with(self.coupon, self.user) assert resp.status_code == status.HTTP_200_OK assert UserCoupon.objects.count() == 1 user_coupon = UserCoupon.objects.get(user=self.user, coupon=self.coupon) assert user_coupon.updated_on > previous_modified assert resp.json() == { 'message': 'Attached user to coupon successfully.', 'coupon': { 'amount': str(self.coupon.amount), 'amount_type': self.coupon.amount_type, 'content_type': self.coupon.content_type.model, 'coupon_type': self.coupon.coupon_type, 'coupon_code': self.coupon.coupon_code, 'object_id': self.coupon.object_id, 'program_id': self.coupon.program.id, } } assert UserCouponAudit.objects.count() == 1 audit = UserCouponAudit.objects.first() assert audit.user_coupon == user_coupon assert audit.data_after == serialize_model_object(user_coupon)
def test_create_user_coupon(self, already_exists): """ Test happy case for creating a UserCoupon """ previous_modified = self.coupon.user_coupon_qset(self.user).first().updated_on if not already_exists: # Won't change anything if it already exists UserCoupon.objects.all().delete() data = { 'username': get_social_username(self.user), } with patch( 'ecommerce.views.is_coupon_redeemable', autospec=True ) as _is_redeemable_mock: _is_redeemable_mock.return_value = True resp = self.client.post( reverse('coupon-user-create', kwargs={'code': self.coupon.coupon_code}), data=data, format='json', ) _is_redeemable_mock.assert_called_with(self.coupon, self.user) assert resp.status_code == status.HTTP_200_OK assert UserCoupon.objects.count() == 1 user_coupon = UserCoupon.objects.get(user=self.user, coupon=self.coupon) assert user_coupon.updated_on > previous_modified assert resp.json() == { 'message': 'Attached user to coupon successfully.', 'coupon': { 'amount': str(self.coupon.amount), 'amount_type': self.coupon.amount_type, 'content_type': self.coupon.content_type.model, 'coupon_type': self.coupon.coupon_type, 'coupon_code': self.coupon.coupon_code, 'object_id': self.coupon.object_id, 'program_id': self.coupon.program.id, } } assert UserCouponAudit.objects.count() == 1 audit = UserCouponAudit.objects.first() assert audit.user_coupon == user_coupon assert audit.data_after == serialize_model_object(user_coupon)
def test_decimal(self): """ Test that a model with a decimal field is handled correctly """ course_run = CourseRunFactory.create() assert serialize_model_object(course_run) == { 'course': course_run.course.id, 'edx_course_key': course_run.edx_course_key, 'end_date': format_as_iso8601(course_run.end_date), 'enrollment_end': format_as_iso8601(course_run.enrollment_end), 'enrollment_start': format_as_iso8601(course_run.enrollment_start), 'enrollment_url': course_run.enrollment_url, 'freeze_grade_date': format_as_iso8601(course_run.freeze_grade_date), 'fuzzy_enrollment_start_date': course_run.fuzzy_enrollment_start_date, 'fuzzy_start_date': course_run.fuzzy_start_date, 'id': course_run.id, 'prerequisites': course_run.prerequisites, 'start_date': format_as_iso8601(course_run.start_date), 'title': course_run.title, 'upgrade_deadline': format_as_iso8601(course_run.upgrade_deadline), }
def test_create_order(self, has_coupon): # pylint: disable=too-many-locals """ Create Order from a purchasable course """ course_run, user = create_purchasable_course_run() discounted_price = round(course_run.course.program.price/2, 2) coupon = None if has_coupon: coupon = CouponFactory.create(content_object=course_run.course) price_tuple = (discounted_price, coupon) with patch( 'ecommerce.api.get_purchasable_course_run', autospec=True, return_value=course_run, ) as get_purchasable, patch( 'ecommerce.api.calculate_run_price', autospec=True, return_value=price_tuple, ) as _calculate_run_price: order = create_unfulfilled_order(course_run.edx_course_key, user) assert get_purchasable.call_count == 1 assert get_purchasable.call_args[0] == (course_run.edx_course_key, user) assert _calculate_run_price.call_count == 1 assert _calculate_run_price.call_args[0] == (course_run, user) assert Order.objects.count() == 1 assert order.status == Order.CREATED assert order.total_price_paid == discounted_price assert order.user == user assert order.line_set.count() == 1 line = order.line_set.first() assert line.course_key == course_run.edx_course_key assert line.description == 'Seat for {}'.format(course_run.title) assert line.price == discounted_price assert OrderAudit.objects.count() == 1 order_audit = OrderAudit.objects.first() assert order_audit.order == order assert order_audit.data_after == order.to_dict() # data_before only has modified_at different, since we only call save_and_log # after Order is already created data_before = order_audit.data_before dict_before = order.to_dict() del data_before['modified_at'] del dict_before['modified_at'] assert data_before == dict_before if has_coupon: assert RedeemedCoupon.objects.count() == 1 redeemed_coupon = RedeemedCoupon.objects.get(order=order, coupon=coupon) assert RedeemedCouponAudit.objects.count() == 1 audit = RedeemedCouponAudit.objects.first() assert audit.redeemed_coupon == redeemed_coupon assert audit.data_after == serialize_model_object(redeemed_coupon) else: assert RedeemedCoupon.objects.count() == 0 assert RedeemedCouponAudit.objects.count() == 0
def test_to_dict(self): """ assert output of to_dict """ financial_aid = FinancialAidFactory.create() assert financial_aid.to_dict() == serialize_model_object(financial_aid)
def to_dict(self): return serialize_model_object(self)
def to_dict(self): """ Get a serialized representation of the Coupon """ return serialize_model_object(self)