def test_unenrolled_verified_student(self, mode, id_verification):
"""
Verify the view return HTTP 303 if the student is unenrolled as verified student in the course
(The Enrollment API call being used returns an inactive enrollment record in this case)
"""
course = CourseFactory()
self.mock_enrollment_api_success_unenrolled(course.id, mode=mode)
product = course.create_or_update_seat(mode, id_verification, 0, self.partner)
stock_record = StockRecordFactory(product=product, partner=self.partner)
catalog = Catalog.objects.create(partner=self.partner)
catalog.stock_records.add(stock_record)
sku = stock_record.partner_sku
url = '{path}?sku={sku}'.format(path=self.path, sku=sku)
response = self.client.get(url)
self.assertEqual(response.status_code, 303)
self.assertEqual(response.wsgi_request.path_info, '/basket/single-item/')
self.assertEqual(response.wsgi_request.GET['sku'], sku)
def test_create_or_update_seat_without_stale_seat_removal(self):
"""
Verify that professional education seats are not deleted if remove_stale_modes flag is not set.
"""
course = CourseFactory()
course.create_or_update_seat('professional', False, 0, self.partner)
self.assertEqual(course.products.count(), 2)
course.create_or_update_seat('professional', True, 0, self.partner, remove_stale_modes=False)
self.assertEqual(course.products.count(), 3)
product_mode = course.products.all()[0]
self.assertEqual(product_mode.attr.id_verification_required, True)
self.assertEqual(product_mode.attr.certificate_type, 'professional')
product_mode = course.products.all()[1]
self.assertEqual(product_mode.attr.id_verification_required, False)
self.assertEqual(product_mode.attr.certificate_type, 'professional')
def test_multiple_providers(self):
""" Verify offer contains information about credit providers. """
course = CourseFactory()
seat1 = course.create_or_update_seat(
'credit', False, 100, partner=self.partner, credit_provider='test_provider_1'
)
seat2 = course.create_or_update_seat(
'credit', False, 100, partner=self.partner, credit_provider='test_provider_2'
)
self.assertEqual(Product.objects.filter(parent=seat1.parent).count(), 2)
self.mock_access_token_response()
__, request, voucher = self.prepare_get_offers_response(seats=[seat1, seat2], seat_type='credit')
self.mock_eligibility_api(request, self.user, course.id)
offers = VoucherViewSet().get_offers(request=request, voucher=voucher)['results']
for offer in offers:
self.assertTrue(offer['multiple_credit_providers'])
self.assertIsNone(offer['credit_provider_price'])
def test_prepare_basket_for_purchased_enrollment_code(self):
"""
Test prepare_basket returns basket with product even if its already been purchased by user
"""
course = CourseFactory()
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
course.create_or_update_seat('verified',
False,
10,
self.partner,
create_enrollment_code=True)
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
with mock.patch.object(UserAlreadyPlacedOrder,
'user_already_placed_order',
return_value=True):
basket = prepare_basket(self.request, [enrollment_code])
self.assertIsNotNone(basket)
def setUp(self):
super(UtilTests, self).setUp()
self.course = CourseFactory(partner=self.partner)
self.verified_seat = self.course.create_or_update_seat(
'verified', False, 100)
self.stock_record = StockRecord.objects.filter(
product=self.verified_seat).first()
self.seat_price = self.stock_record.price_excl_tax
self._range = RangeFactory(products=[
self.verified_seat,
])
self.percentage_benefit = BenefitFactory(type=Benefit.PERCENTAGE,
range=self._range,
value=35.00)
self.value_benefit = BenefitFactory(type=Benefit.FIXED,
range=self._range,
value=self.seat_price - 10)
def test_seat_products(self):
"""
Verify the method returns a list containing purchasable course seats.
These seats should be the child products.
"""
# Create a new course and verify it has a parent product, but no children.
course = CourseFactory(partner=self.partner)
self.assertEqual(course.products.count(), 1)
self.assertEqual(len(course.seat_products), 0)
# Create the seat products
seats = [course.create_or_update_seat('honor', False, 0),
course.create_or_update_seat('verified', True, 50, create_enrollment_code=True)]
self.assertEqual(course.products.count(), 4)
# The property should return only the child seats.
self.assertEqual(set(course.seat_products), set(seats))
def setUp(self):
super(SailthruSignalTests, self).setUp()
self.request.COOKIES['sailthru_bid'] = CAMPAIGN_COOKIE
self.user = UserFactory.create(username='******', email=TEST_EMAIL)
toggle_switch('sailthru_enable', True)
self.site_configuration.enable_sailthru = True
self.site_configuration.save()
# create some test course objects
self.course_id = 'edX/toy/2012_Fall'
self.course_url = 'http://lms.testserver.fake/courses/edX/toy/2012_Fall/info'
self.course = CourseFactory(id=self.course_id,
name='Demo Course',
partner=self.partner)
self.basket_attribute_type, __ = BasketAttributeType.objects.get_or_create(
name=SAILTHRU_CAMPAIGN)
def test_already_purchased_product(self):
"""
Verify student can not place multiple orders for single course seat
"""
course = CourseFactory()
product = course.create_or_update_seat("Verified", True, 0, self.partner)
stock_record = StockRecordFactory(product=product, partner=self.partner)
catalog = Catalog.objects.create(partner=self.partner)
catalog.stock_records.add(stock_record)
sku = stock_record.partner_sku
basket = factories.BasketFactory(owner=self.user, site=self.site)
basket.add_product(product, 1)
create_order(user=self.user, basket=basket)
url = '{path}?sku={sku}'.format(path=self.path, sku=sku)
expected_content = 'You have already purchased {course} seat.'.format(course=product.course.name)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['error'], expected_content)
def test_create_seat_with_enrollment_code(self):
"""Verify an enrollment code product is created."""
course = CourseFactory()
seat_type = 'verified'
price = 5
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
course.create_or_update_seat(seat_type, True, price, self.partner)
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
self.assertEqual(enrollment_code.attr.course_key, course.id)
self.assertEqual(enrollment_code.attr.seat_type, seat_type)
stock_record = StockRecord.objects.get(product=enrollment_code)
self.assertEqual(stock_record.price_excl_tax, price)
self.assertEqual(stock_record.price_currency,
settings.OSCAR_DEFAULT_CURRENCY)
self.assertEqual(stock_record.partner, self.partner)
def test_enrolled_verified_student(self, mode, id_verification):
"""
Verify the view return HTTP 400 if the student is already enrolled as verified student in the course
(The Enrollment API call being used returns an active enrollment record in this case)
"""
course = CourseFactory()
self.mock_enrollment_api_success_enrolled(course.id, mode=mode)
product = course.create_or_update_seat(mode, id_verification, 0, self.partner)
stock_record = StockRecordFactory(product=product, partner=self.partner)
catalog = Catalog.objects.create(partner=self.partner)
catalog.stock_records.add(stock_record)
self.create_coupon(catalog=catalog, code=COUPON_CODE, benefit_value=5)
url = '{path}?sku={sku}&code={code}'.format(path=self.path, sku=stock_record.partner_sku, code=COUPON_CODE)
expected_content = 'You are already enrolled in {product}.'.format(product=product.course.name)
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content, expected_content)
def prepare_order(self, seat_type, credit_provider_id=None):
"""
Prepares order for a post-checkout test.
Args:
seat_type (str): Course seat type
credit_provider_id (str): Credit provider associated with the course seat.
Returns:
Order
"""
course = CourseFactory(partner=self.partner)
seat = course.create_or_update_seat(seat_type, False, 50,
credit_provider_id, None, 2)
basket = factories.BasketFactory(owner=self.user, site=self.site)
basket.add_product(seat, 1)
order = create_order(basket=basket, user=self.user)
return order
def test_track_completed_enrollment_order(self):
""" Make sure we do not send GA events for Enrollment Code orders """
with mock.patch('ecommerce.extensions.checkout.signals.track_segment_event') as mock_track:
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
site_config = self.site.siteconfiguration
site_config.enable_enrollment_codes = True
site_config.save()
course = CourseFactory()
course.create_or_update_seat('verified', True, 50, self.partner, create_enrollment_code=True)
enrollment_code = Product.objects.get(product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
basket = factories.BasketFactory(owner=self.user, site=self.site)
basket.add_product(enrollment_code)
order = factories.create_order(basket=basket, user=self.user)
track_completed_order(None, order)
assert not mock_track.called
def test_execution_for_bulk_purchase(self):
"""
Verify redirection to LMS receipt page after attempted payment
execution if the Otto receipt page is disabled for bulk purchase and
also that the order is linked to the provided business client..
"""
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
self.mock_oauth2_response()
course = CourseFactory(partner=self.partner)
course.create_or_update_seat('verified', True, 50, create_enrollment_code=True)
self.basket = create_basket(owner=UserFactory(), site=self.site)
enrollment_code = Product.objects.get(product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
factories.create_stockrecord(enrollment_code, num_in_stock=2, price_excl_tax='10.00')
self.basket.add_product(enrollment_code, quantity=1)
# Create a payment record the view can use to retrieve a basket
self.mock_payment_creation_response(self.basket)
self.processor.get_transaction_parameters(self.basket, request=self.request)
self.mock_payment_execution_response(self.basket)
self.mock_payment_creation_response(self.basket, find=True)
# Manually add organization attribute on the basket for testing
self.RETURN_DATA.update({'organization': 'Dummy Business Client'})
self.RETURN_DATA.update({PURCHASER_BEHALF_ATTRIBUTE: 'False'})
basket_add_organization_attribute(self.basket, self.RETURN_DATA)
response = self.client.get(reverse('paypal:execute'), self.RETURN_DATA)
self.assertRedirects(
response,
get_receipt_page_url(
order_number=self.basket.order_number,
site_configuration=self.basket.site.siteconfiguration,
disable_back_button=True,
),
fetch_redirect_response=False
)
# Now verify that a new business client has been created and current
# order is now linked with that client through Invoice model.
order = Order.objects.filter(basket=self.basket).first()
business_client = BusinessClient.objects.get(name=self.RETURN_DATA['organization'])
assert Invoice.objects.get(order=order).business_client == business_client
def setUp(self):
super(EntitlementsTests, self).setUp()
self.learner = self.create_user(is_staff=True)
self.client.login(username=self.learner.username,
password=self.password)
# Enable enterprise functionality
toggle_switch(settings.ENABLE_ENTERPRISE_ON_RUNTIME_SWITCH, True)
self.course = CourseFactory(id='edx/Demo_Course/DemoX',
partner=self.partner)
course_seat = self.course.create_or_update_seat('verified', False, 100)
stock_record = StockRecord.objects.get(product=course_seat)
self.catalog = Catalog.objects.create(partner=self.partner)
self.catalog.stock_records.add(stock_record)
self.request.user = self.learner
self.request.site = self.site
self.request.strategy = DefaultStrategy()
def test_add_product_not_tracked_for_temporary_basket_calculation(self):
"""
Verify the method does NOT fire Product Added analytic event when a product is added to the basket
TODO: LEARNER 5463
"""
course = CourseFactory()
basket = create_basket(empty=True)
seat = course.create_or_update_seat('verified', True, 100,
self.partner)
RequestCache.set(TEMPORARY_BASKET_CACHE_KEY, True)
with mock.patch(
'ecommerce.extensions.basket.models.track_segment_event'
) as mock_track:
basket.add_product(seat)
properties = translate_basket_line_for_segment(
basket.lines.first())
properties['cart_id'] = basket.id
mock_track.assert_not_called()
def test_more_than_one_product(self):
"""
Test that we do not send email if basket contains more
than one product
"""
coupon = self.create_coupon()
course = CourseFactory(partner=self.partner)
seat = course.create_or_update_seat('verified', False, 50, None, None,
2)
basket = factories.BasketFactory(owner=self.user, site=self.site)
basket.add_product(seat)
basket.add_product(coupon)
order = create_order(basket=basket, user=self.user)
with LogCapture(LOGGER_NAME) as logger:
send_course_purchase_email(None, user=self.user, order=order)
logger.check(
(LOGGER_NAME, 'INFO',
'Currently support receipt emails for order with one item.'))
def test_basket_switch_data(self):
"""Verify the correct basket switch data (single vs. multi quantity) is retrieved."""
course = CourseFactory()
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
seat = course.create_or_update_seat('verified',
False,
10,
self.partner,
create_enrollment_code=True)
seat_sku = StockRecord.objects.get(product=seat).partner_sku
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
ec_sku = StockRecord.objects.get(product=enrollment_code).partner_sku
__, partner_sku = get_basket_switch_data(seat)
self.assertEqual(partner_sku, ec_sku)
__, partner_sku = get_basket_switch_data(enrollment_code)
self.assertEqual(partner_sku, seat_sku)
def setUp(self):
super(BasketSummaryViewTests, self).setUp()
self.user = self.create_user()
self.client.login(username=self.user.username, password=self.password)
self.course = CourseFactory(name='BasketSummaryTest')
site_configuration = SiteConfiguration.objects.get(site__id=1)
old_payment_processors = site_configuration.payment_processors
site_configuration.payment_processors = DummyProcessor.NAME
site_configuration.save()
def reset_site_config():
""" Reset method - resets site_config to pre-test state """
site_configuration.payment_processors = old_payment_processors
site_configuration.save()
self.addCleanup(reset_site_config)
toggle_switch(settings.PAYMENT_PROCESSOR_SWITCH_PREFIX + DummyProcessor.NAME, True)
def test_list(self):
""" Verify the view returns a list of Courses. """
CourseFactory()
self.assertEqual(Course.objects.count(), 2)
response = self.client.get(self.list_path)
self.assertEqual(response.status_code, 200)
self.assertListEqual(response.json()['results'],
[self.serialize_course(self.course)])
# If no Courses exist, the view should return an empty results list.
Course.objects.all().delete()
response = self.client.get(self.list_path)
self.assertDictEqual(response.json(), {
'count': 0,
'next': None,
'previous': None,
'results': []
})
def test_is_course_in_enterprise_catalog_for_unavailable_course(self):
"""
Verify that method "is_course_in_enterprise_catalog" returns False if
the provided course is not available in the enterprise course catalog.
"""
enterprise_catalog_id = 1
self.mock_access_token_response()
self.mock_catalog_contains_endpoint(
discovery_api_url=self.site_configuration.discovery_api_url, catalog_id=enterprise_catalog_id,
course_run_ids=[self.course.id]
)
test_course = CourseFactory(id='edx/Non_Enterprise_Course/DemoX')
is_course_available = is_course_in_enterprise_catalog(self.request.site, test_course.id, enterprise_catalog_id)
# Verify that there only one call for the course discovery API for
# checking if course exists in course runs against the course catalog.
self._assert_num_requests(2)
self.assertFalse(is_course_available)
def test_omitting_expired_courses(self):
"""Verify professional courses who's enrollment end datetime have passed are omitted."""
no_enrollment_end_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
no_enrollment_start_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
valid_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
expired_enrollment_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
expired_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
future_enrollment_seat = CourseFactory(partner=self.partner).create_or_update_seat('professional', False, 100)
course_discovery_results = [
{
'key': no_enrollment_end_seat.attr.course_key,
'enrollment_end': None,
'enrollment_start': str(now() - datetime.timedelta(days=1)),
},
{
'key': no_enrollment_start_seat.attr.course_key,
'enrollment_start': None,
'enrollment_end': None,
},
{
'key': valid_seat.attr.course_key,
'enrollment_end': str(now() + datetime.timedelta(days=1)),
'enrollment_start': str(now() - datetime.timedelta(days=1)),
},
{
'key': expired_enrollment_seat.attr.course_key,
'enrollment_end': str(now() - datetime.timedelta(days=1)),
'enrollment_start': str(now() - datetime.timedelta(days=1)),
},
{
'key': expired_seat.attr.course_key,
'enrollment_end': None,
'enrollment_start': str(now() - datetime.timedelta(days=1)),
'end': str(now() - datetime.timedelta(days=1)),
},
{
'key': future_enrollment_seat.attr.course_key,
'enrollment_end': None,
'enrollment_start': str(now() + datetime.timedelta(days=1)),
}
]
products, _, __ = VoucherViewSet().retrieve_course_objects(course_discovery_results, 'professional')
self.assertIn(no_enrollment_end_seat, products)
self.assertIn(no_enrollment_start_seat, products)
self.assertIn(valid_seat, products)
self.assertNotIn(expired_enrollment_seat, products)
self.assertNotIn(expired_seat, products)
self.assertNotIn(future_enrollment_seat, products)
def setUp(self):
super(UtilTests, self).setUp()
self.user = self.create_user(full_name="Tešt Ušer", is_staff=True)
self.client.login(username=self.user.username, password=self.password)
self.course = CourseFactory(id='course-v1:test-org+course+run',
partner=self.partner)
self.verified_seat = self.course.create_or_update_seat(
'verified', False, 100)
self.catalog = Catalog.objects.create(partner=self.partner)
self.stock_record = StockRecord.objects.filter(
product=self.verified_seat).first()
self.seat_price = self.stock_record.price_excl_tax
self.catalog.stock_records.add(self.stock_record)
self.coupon = self.create_coupon(title='Tešt product',
catalog=self.catalog,
note='Tešt note',
quantity=1,
max_uses=1,
voucher_type=Voucher.MULTI_USE)
self.coupon_vouchers = CouponVouchers.objects.filter(
coupon=self.coupon)
self.data = {
'benefit_type': Benefit.PERCENTAGE,
'benefit_value': 100.00,
'catalog': self.catalog,
'coupon': self.coupon,
'end_datetime':
datetime.datetime.now() + datetime.timedelta(days=1),
'enterprise_customer': None,
'enterprise_customer_catalog': None,
'name': "Test voucher",
'quantity': 10,
'start_datetime':
datetime.datetime.now() - datetime.timedelta(days=1),
'voucher_type': Voucher.SINGLE_USE
}
def test_enrollment_code_seat_type_filter(self):
""" Verify that the ENROLLMENT_CODE_SEAT_TYPES constant is properly applied during seat creation """
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
course = CourseFactory(id='test/course/123',
name='Test Course 123',
site=self.site)
# Audit seat products should not have a corresponding enrollment code
course.create_or_update_seat('audit',
False,
0,
self.partner,
create_enrollment_code=True)
with self.assertRaises(Product.DoesNotExist):
Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
# Honor seat products should not have a corresponding enrollment code
course.create_or_update_seat('honor',
False,
0,
self.partner,
create_enrollment_code=True)
with self.assertRaises(Product.DoesNotExist):
Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
# Verified seat products should have a corresponding enrollment code
course.create_or_update_seat('verified',
True,
10,
self.partner,
create_enrollment_code=True)
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
self.assertEqual(enrollment_code.attr.course_key, course.id)
self.assertEqual(enrollment_code.attr.seat_type, 'verified')
# One parent product, three seat products, one enrollment code product (verified) -> five total products
self.assertEqual(course.products.count(), 5)
self.assertEqual(len(course.seat_products),
3) # Definitely three seat products...
def test_stop_sailthru_update_on_multi_product_baskets(self, mock_log_error, mock_update_course_enrollment):
""" Verify Sailthru is not contacted for multi-product baskets. """
# Create multi-product basket
seat = self.course.create_or_update_seat('verified', False, 100, self.partner, None)
other_course = CourseFactory(site=self.site)
other_seat = other_course.create_or_update_seat('verified', False, 100, self.partner, None)
basket = BasketFactory(owner=self.user, site=self.site)
basket.add_product(seat)
basket.add_product(other_seat)
multi_product_order = create_order(number=2, basket=basket, user=self.user, site=self.site)
# This method takes an argument to determine whether that product is part of a multi-product basket
process_basket_addition(None, request=self.request, user=self.user, product=seat, is_multi_product_basket=True)
self.assertFalse(mock_update_course_enrollment.called)
self.assertFalse(mock_log_error.called)
# This method looks at the number of lines in the order to determine if the basket has multiple products
process_checkout_complete(None, order=multi_product_order, request=None)
self.assertFalse(mock_update_course_enrollment.called)
self.assertFalse(mock_log_error.called)
def test_prepare_basket_enrollment_with_voucher(self):
"""Verify the basket does not contain a voucher if enrollment code is added to it."""
course = CourseFactory(partner=self.partner)
course.create_or_update_seat('verified',
False,
10,
create_enrollment_code=True)
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
voucher, product = prepare_voucher()
basket = prepare_basket(self.request, [product], voucher)
self.assertIsNotNone(basket)
self.assertEqual(basket.all_lines()[0].product, product)
self.assertTrue(basket.contains_a_voucher)
basket = prepare_basket(self.request, [enrollment_code], voucher)
self.assertIsNotNone(basket)
self.assertEqual(basket.all_lines()[0].product, enrollment_code)
self.assertFalse(basket.contains_a_voucher)
def test_is_course_in_enterprise_catalog_for_unavailable_course(self):
"""
Verify that method "is_course_in_enterprise_catalog" returns False if
the provided course is not available in the enterprise course catalog.
"""
enterprise_catalog_id = 1
catalog_query = '*:*'
self.mock_course_discovery_api_for_catalog_by_resource_id(
catalog_id=enterprise_catalog_id, catalog_query=catalog_query
)
self.mock_dynamic_catalog_contains_api(query=catalog_query, course_run_ids=[self.course.id])
test_course = CourseFactory(id='edx/Non_Enterprise_Course/DemoX')
is_course_available = is_course_in_enterprise_catalog(self.request.site, test_course.id, enterprise_catalog_id)
# Verify that there were two calls for the course discovery API, one
# for getting enterprise course catalog and the other for verifying if
# course exists in course runs against the course catalog query
self._assert_num_requests(2)
self.assertFalse(is_course_available)
def test_all_already_purchased_products(self):
"""
Test user can not purchase products again using the multiple item view
"""
course = CourseFactory()
product1 = course.create_or_update_seat("Verified", True, 0, self.partner)
product2 = course.create_or_update_seat("Professional", True, 0, self.partner)
stock_record = StockRecordFactory(product=product1, partner=self.partner)
catalog = Catalog.objects.create(partner=self.partner)
catalog.stock_records.add(stock_record)
stock_record = StockRecordFactory(product=product2, partner=self.partner)
catalog.stock_records.add(stock_record)
qs = urllib.urlencode({'sku': [product.stockrecords.first().partner_sku for product in [product1, product2]]},
True)
url = '{root}?{qs}'.format(root=self.path, qs=qs)
with mock.patch.object(UserAlreadyPlacedOrder, 'user_already_placed_order', return_value=True):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['error'], 'You have already purchased these products')
def test_generate_coupon_report_with_deleted_product(self):
""" Verify the coupon report contains correct data for coupon with fixed benefit type. """
course = CourseFactory(id='course-v1:del-org+course+run',
partner=self.partner)
professional_seat = course.create_or_update_seat(
'professional', False, 100)
query_coupon = self.create_catalog_coupon(catalog_query='course:*')
vouchers = query_coupon.attr.coupon_vouchers.vouchers.all()
first_voucher = vouchers.first()
self.use_voucher('TESTORDER1',
first_voucher,
self.user,
product=professional_seat)
professional_seat.delete()
__, rows = generate_coupon_report([query_coupon.attr.coupon_vouchers])
self.assert_report_first_row(rows[0], query_coupon, first_voucher)
self.assertDictContainsSubset({'Redeemed For Course ID': 'Unknown'},
rows[2])
def test_no_switch_link(self):
"""Verify response does not contain variables for the switch link if seat does not have an EC."""
no_ec_course = CourseFactory()
seat_without_ec = no_ec_course.create_or_update_seat('verified', False, 10, self.partner)
self.create_basket_and_add_product(seat_without_ec)
self.mock_dynamic_catalog_course_runs_api(course_run=no_ec_course)
response = self.client.get(self.path)
self.assertFalse(response.context['switch_link_text'])
self.assertFalse(response.context['partner_sku'])
ec_course, seat_with_ec, enrollment_code = self.prepare_course_seat_and_enrollment_code()
Basket.objects.all().delete()
self.create_basket_and_add_product(seat_with_ec)
self.mock_dynamic_catalog_course_runs_api(course_run=ec_course)
response = self.client.get(self.path)
enrollment_code_stockrecord = StockRecord.objects.get(product=enrollment_code)
self.assertTrue(response.context['switch_link_text'])
self.assertEqual(response.context['partner_sku'], enrollment_code_stockrecord.partner_sku)
def test_not_already_purchased_product(self):
"""
Verify student can place order for not purchased product
"""
course = CourseFactory()
product = course.create_or_update_seat("Verified", True, 0,
self.partner)
stock_record = StockRecordFactory(product=product,
partner=self.partner)
catalog = Catalog.objects.create(partner=self.partner)
catalog.stock_records.add(stock_record)
sku = stock_record.partner_sku
url = '{path}?sku={sku}'.format(path=self.path, sku=sku)
response = self.client.get(url)
self.assertEqual(response.status_code, 303)
self.assertEqual(response.wsgi_request.path_info,
'/basket/single-item/')
self.assertEqual(response.wsgi_request.GET['sku'], sku)
