def test_serialize_basket_product_version_program(mock_context):
"""Test ProductVersion serialization for a Program"""
program = ProgramFactory.create()
courses = CourseFactory.create_batch(3, program=program)
product_version = ProductVersionFactory.create(
product=ProductFactory(content_object=program)
)
data = FullProductVersionSerializer(
instance=product_version, context=mock_context
).data
assert data == {
"id": product_version.id,
"description": product_version.description,
"content_title": product_version.product.content_object.title,
"price": str(round_half_up(product_version.price)),
"type": product_version.product.content_type.model,
"courses": [
CourseSerializer(instance=course, context=mock_context).data
for course in courses
],
"thumbnail_url": program.catalog_image_url,
"object_id": product_version.product.object_id,
"product_id": product_version.product.id,
"readable_id": get_readable_id(product_version.product.content_object),
"run_tag": None,
"created_on": product_version.created_on.strftime(datetime_millis_format),
"start_date": product_version.product.content_object.next_run_date.isoformat()
if product_version.product.content_object.next_run_date
else None,
}
def test_order_status(client):
"""
The order status API should provide information about the order based on its unique_id.
"""
order = B2BOrderFactory.create()
resp = client.get(
reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)})
)
assert resp.status_code == status.HTTP_200_OK
assert_drf_json_equal(
resp.json(),
{
"email": order.email,
"num_seats": order.num_seats,
"product_version": FullProductVersionSerializer(
order.product_version, context={"all_runs": True}
).data,
"item_price": str(order.per_item_price),
"total_price": str(order.total_price),
"status": order.status,
"discount": None,
"created_on": order.created_on,
"reference_number": order.reference_number,
"coupon_code": order.coupon.coupon_code if order.coupon else None,
"contract_number": order.contract_number,
"receipt_data": {"card_type": None, "card_number": None},
},
)
def test_serialize_basket_product_version_programrun(mock_context):
"""Test ProductVersion serialization for a Program with an associated ProgramRun"""
program_run = ProgramRunFactory()
product_version = ProductVersionFactory.create(
product=ProductFactory(content_object=program_run.program)
)
context = {**mock_context, **{"program_run": program_run}}
data = FullProductVersionSerializer(instance=product_version, context=context).data
assert data["object_id"] == program_run.program.id
assert data["run_tag"] == program_run.run_tag
def test_basket_thumbnail_program(basket_and_coupons, mock_context):
"""Basket thumbnail should be serialized for a program"""
thumbnail_filename = "abcde.jpg"
program_page = ProgramPageFactory.create(
thumbnail_image__file__filename=thumbnail_filename
)
program = program_page.program
product_version = ProductVersionFactory.create(product__content_object=program)
data = FullProductVersionSerializer(
instance=product_version, context=mock_context
).data
assert (
data["thumbnail_url"]
== program_page.thumbnail_image.get_rendition(
CATALOG_COURSE_IMG_WAGTAIL_FILL
).url
)
def test_basket_thumbnail_courserun(basket_and_coupons, mock_context):
"""Basket thumbnail should be serialized for a courserun"""
thumbnail_filename = "abcde.jpg"
course_page = CoursePageFactory.create(
thumbnail_image__file__filename=thumbnail_filename
)
run = CourseRunFactory.create(course=course_page.course)
product_version = ProductVersionFactory.create(product__content_object=run)
data = FullProductVersionSerializer(
instance=product_version, context=mock_context
).data
assert (
data["thumbnail_url"]
== course_page.thumbnail_image.get_rendition(
CATALOG_COURSE_IMG_WAGTAIL_FILL
).url
)
def get(self, request, *args, **kwargs): # pylint: disable=unused-argument
"""Return B2B order status and other information about the order needed to display the receipt"""
order_hash = kwargs["hash"]
order = get_object_or_404(B2BOrder, unique_id=order_hash)
receipt = B2BReceipt.objects.filter(
order=order).order_by("-created_on").first()
receipt_data = {"card_number": None, "card_type": None}
if receipt:
receipt_data["card_number"] = receipt.data.get("req_card_number")
receipt_data["card_type"] = CYBERSOURCE_CARD_TYPES.get(
receipt.data.get("req_card_type"))
return Response(
data={
"status":
order.status,
"num_seats":
order.num_seats,
"total_price":
str(order.total_price),
"item_price":
str(order.per_item_price),
"discount":
str(order.discount) if order.discount is not None else None,
"product_version":
FullProductVersionSerializer(order.product_version,
context={
"all_runs": True
}).data,
"email":
order.email,
"contract_number":
order.contract_number,
"created_on":
order.created_on,
"reference_number":
order.reference_number,
"coupon_code":
order.coupon.coupon_code if order.coupon else None,
"receipt_data":
receipt_data,
})
def test_serialize_basket(basket_and_agreement, mock_context, is_live):
"""Test Basket serialization"""
basket = basket_and_agreement.basket
selection = CouponSelection.objects.get(basket=basket)
run = CourseRunSelection.objects.get(basket=basket).run
data_consent = DataConsentUser.objects.get(user=basket.user)
run.live = is_live
run.save()
data = BasketSerializer(instance=basket, context=mock_context).data
assert data == {
"items": [
{
**FullProductVersionSerializer(
instance=basket_and_agreement.product.latest_version,
context=mock_context,
).data,
"run_ids": [run.id] if is_live else [],
}
],
"coupons": [CouponSelectionSerializer(selection).data],
"data_consents": [DataConsentUserSerializer(data_consent).data],
}