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 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_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_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_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_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)
def to_dict(self):
return serialize_model_object(self)
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 to_dict(self):
"""
Get a serialized representation of the Coupon
"""
return serialize_model_object(self)
