def _create_cart(self):
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
self.cart = get_or_create_cart(self.request)
self.cart.add_product(self.product, 1)
self.cart.save()
def _create_mock_diary(self):
self.diary = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.diary.name = 'Diary'
self.diary.slug = 'mock-diary'
self.diary.short_description = 'test'
self.diary.long_description = 'test'
self.diary.unit_price = Decimal('1.0')
self.diary.save()
options_group = OptionGroup.objects.all()[0]
self.diary.options_groups.add(options_group)
text_options = TextOption.objects.all()[0]
self.diary.text_options.add(text_options)
def setUp(self):
self.request = Mock()
setattr(self.request, 'session', {})
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
setattr(self.request, 'user', self.user)
def _create_mock_diary(self):
self.diary = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.diary.name = 'Diary'
self.diary.slug = 'mock-diary'
self.diary.short_description = 'test'
self.diary.long_description = 'test'
self.diary.unit_price = Decimal('1.0')
self.diary.save()
options_group = OptionGroup.objects.all()[0]
self.diary.options_groups.add(options_group)
text_options = TextOption.objects.all()[0]
self.diary.text_options.add(text_options)
def setUp(self):
self.request = Mock()
setattr(self.request, 'session', {})
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
setattr(self.request, 'user', self.user)
class ProductVariationsTest(TestCase):
def setUp(self):
"""Sets up the TestModel."""
self._create_options()
self._create_mock_diary()
self._create_mock_calendar()
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
def test_get_product_returns_correctly(self):
request = Mock()
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
setattr(view, 'object', None)
obj = view.get_object()
self.assertTrue(isinstance(obj, DiaryProduct))
def test_get_templates_return_expected_values(self):
view = DiaryDetailView()
setattr(view, 'object', None)
tmp = view.get_template_names()
self.assertGreaterEqual(len(tmp), 1)
def test_add_diary_to_cart_using_post(self):
# create form data with a product containing variations and simulate POST
post = {
'product_action': 'add_to_cart',
'add_item_id': self.diary.id,
'add_item_quantity': 1,
'add_item_option_group_1': 2, # Color: green
'add_item_text_option_1': 'Doctor Diary', # Engraving
}
request = self._get_post_request(post)
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
view.post()
ret = self._get_from_cart()
# check if the product is in the cart
self.assertEqual(len(ret['cart_items']), 1)
values = ret['cart_items'].values()[0]
self.assertEqual(values['product_id'], self.diary.id)
self.assertEqual(values['quantity'], 1)
variation = json.loads(values['variation'])
self.assertEqual(variation['option_groups']['1']['name'], 'Color')
self.assertEqual(variation['option_groups']['1']['option']['name'],
'green')
self.assertEqual(variation['text_options']['1']['text'],
'Doctor Diary')
# add the same product with missing quantity field
del post['add_item_quantity']
request = self._get_post_request(post)
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
view.post()
ret = self._get_from_cart()
values = ret['cart_items'].values()[0]
self.assertEqual(values['quantity'], 2)
def test_add_calendar_to_cart_using_post(self):
# create form data with a product containing variations and simulate POST
post = {
'product_action': 'add_to_cart',
'add_item_id': self.calendar.id,
'add_item_quantity': 1,
'add_item_option_group_1': 1, # Color: red
}
request = self._get_post_request(post)
view = CalendarDetailView(request=request,
kwargs={'pk': self.calendar.id})
setattr(view, 'object', None)
view.post()
ret = self._get_from_cart()
# check if the product is in the cart
self.assertEqual(len(ret['cart_items']), 1)
values = ret['cart_items'].values()[0]
self.assertEqual(values['product_id'], self.calendar.id)
self.assertEqual(values['quantity'], 1)
variation = json.loads(values['variation'])
self.assertEqual(variation['option_groups']['1']['name'], 'Color')
self.assertEqual(variation['option_groups']['1']['option']['name'],
'red')
self.assertFalse('text_options' in variation)
def _get_post_request(self, post):
request = Mock()
setattr(request, 'is_ajax', lambda: False)
setattr(request, 'user', self.user)
setattr(request, 'POST', post)
return request
def _get_from_cart(self):
request = Mock()
setattr(request, 'user', self.user)
view = CartDetails(request=request)
ret = view.get_context_data()
self.assertNotEqual(ret, None)
return ret
def _create_options(self):
option_group = OptionGroup(name='Color', slug='color')
option_group.save()
price = Decimal('1.25')
Option(name='red', price=price, group=option_group).save()
Option(name='green', price=price, group=option_group).save()
Option(name='blue', price=price, group=option_group).save()
TextOption(name='Engraving', price=price, max_length=12).save()
def _create_mock_diary(self):
self.diary = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.diary.name = 'Diary'
self.diary.slug = 'mock-diary'
self.diary.short_description = 'test'
self.diary.long_description = 'test'
self.diary.unit_price = Decimal('1.0')
self.diary.save()
options_group = OptionGroup.objects.all()[0]
self.diary.options_groups.add(options_group)
text_options = TextOption.objects.all()[0]
self.diary.text_options.add(text_options)
def _create_mock_calendar(self):
self.calendar = CalendarProduct(isbn='1234567890', number_of_pages=100)
self.calendar.name = 'Calendar'
self.calendar.slug = 'mock-calendar'
self.calendar.short_description = 'test'
self.calendar.long_description = 'test'
self.calendar.unit_price = Decimal('1.0')
self.calendar.save()
options_group = OptionGroup.objects.all()[0]
self.calendar.options_groups.add(options_group)
class WishlistsTest(TestCase):
def setUp(self):
self.request = Mock()
setattr(self.request, 'session', {})
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
setattr(self.request, 'user', self.user)
def test_get_templates_return_expected_values(self):
view = DiaryDetailView()
setattr(view, 'object', None)
tmp = view.get_template_names()
self.assertGreaterEqual(len(tmp), 1)
def test_no_wishlist_for_anonymous_user(self):
"""Wishlists for anonymous users are not allowed"""
setattr(self.request, 'user', None)
self.assertRaises(exceptions.PermissionDenied, get_or_create_wishlist,
self.request)
self.assertRaises(exceptions.PermissionDenied,
create_additional_wishlist, self.request)
def test_create_wishlist(self):
"""Asking for a wishlist twice, shall create only one"""
wishlist = get_or_create_wishlist(self.request)
# check that wishlist is stored in request
self.assertEqual(wishlist, get_or_create_wishlist(self.request))
self.assertTrue(hasattr(self.request, '_wishlist'))
self.assertTrue(self.request.session.has_key('active_wishlist'))
# check that wishlist is stored in session
request = Mock()
setattr(request, 'session', {'active_wishlist': wishlist.id})
setattr(request, 'user', self.user)
self.assertEqual(wishlist, get_or_create_wishlist(request))
# check that wishlist is stored for current user
request = Mock()
setattr(request, 'session', {})
setattr(request, 'user', self.user)
self.assertEqual(wishlist, get_or_create_wishlist(request))
self.assertEqual(request.session['active_wishlist'], wishlist.id)
self.assertEqual(request._wishlist, wishlist)
def test_do_not_share_wishlists(self):
""""Different users shall never share a wishlist"""
wishlist = get_or_create_wishlist(self.request)
request = Mock()
setattr(request, 'session', {})
user2 = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test2",
last_name="Tester2")
setattr(request, 'user', user2)
self.assertNotEqual(wishlist, get_or_create_wishlist(request))
def test_is_product_on_active_wishlist(self):
"""A product IS on the wishlist independently of its variation"""
wishlist = get_or_create_wishlist(self.request)
variation1 = {'foo': 'bar'}
variation2 = {'foo': 'baz'}
wishlist.add_product(self.product, variation=variation1)
wishlist.add_product(self.product, variation=variation2)
self.assertTrue(
is_product_on_active_wishlist(self.request, self.product))
items = wishlist.get_all_items()
self.assertEqual(len(items), 2)
wishlist.delete_item(items[0].id)
self.assertEqual(len(wishlist.get_all_items()), 1)
self.assertTrue(
is_product_on_active_wishlist(self.request, self.product))
wishlist.delete_item(items[1].id)
self.assertFalse(
is_product_on_active_wishlist(self.request, self.product))
def test_find_product_on_active_wishlist(self):
"""Products added to the wishlist must be found again"""
wishlist = get_or_create_wishlist(self.request)
variation = {'foo': 'bar'}
wishlist.add_product(self.product, variation=variation)
self.assertEqual(len(wishlist.get_all_items()), 1)
items = wishlist.find_item(self.product)
self.assertEqual(len(items), 0)
items = wishlist.find_item(self.product, variation=variation)
self.assertEqual(len(items), 1)
wishlist.add_product(self.product, variation={'foo': 'baz'})
self.assertEqual(len(wishlist.get_all_items()), 2)
wishlist.add_product(self.product)
self.assertEqual(len(wishlist.get_all_items()), 3)
def test_copy_product_to_cart(self):
"""Products added to the wishlist must be transferable to the cart"""
wishlist = get_or_create_wishlist(self.request)
variation = {'foo': 'bar'}
wishlist.add_product(self.product, variation=variation)
self.assertEqual(len(wishlist.get_all_items()), 1)
item = wishlist.get_all_items()[0]
copy_item_to_cart(self.request, item.id)
cart = get_or_create_cart(self.request)
cart_item = CartItem.objects.all()[0]
self.assertEqual(self.product, cart_item.product)
self.assertEqual(variation, cart_item.variation)
def test_create_additional_wishlist(self):
get_or_create_wishlist(self.request)
self.assertEqual(Wishlist.objects.all().count(), 1)
wishlist = create_additional_wishlist(self.request)
self.assertEqual(Wishlist.objects.all().count(), 2)
self.assertEqual(self.request._wishlist, wishlist)
self.assertEqual(self.request.session['active_wishlist'], wishlist.id)
self.assertEqual(self.request._wishlist, wishlist)
def test_switch_wishlist(self):
self.assertRaises(exceptions.ObjectDoesNotExist, switch_wishlist,
self.request, 987)
wishlist1 = get_or_create_wishlist(self.request)
wishlist2 = create_additional_wishlist(self.request)
self.assertEqual(self.request.session['active_wishlist'], wishlist2.id)
self.assertEqual(self.request._wishlist, wishlist2)
switch_wishlist(self.request, wishlist1.id)
self.assertEqual(self.request.session['active_wishlist'], wishlist1.id)
self.assertEqual(self.request._wishlist, wishlist1)
def test_rename_wishlist(self):
"""Products added to the wishlist must be found again"""
self.assertRaises(exceptions.ObjectDoesNotExist,
rename_active_wishlist, self.request, 'DEF')
wishlist = get_or_create_wishlist(self.request)
self.assertEqual(wishlist.name, _('My wishlist'))
rename_active_wishlist(self.request, 'ABC')
self.assertEqual(wishlist.name, 'ABC')
request = Mock()
setattr(request, 'user', self.user)
setattr(request, 'session', {'active_wishlist': wishlist.id})
rename_active_wishlist(request, 'DEF')
wishlist = get_or_create_wishlist(request)
self.assertEqual(wishlist.name, 'DEF')
def test_delete_wishlist(self):
"""Deleting a wishlist also deletes all its items"""
self.assertRaises(exceptions.ObjectDoesNotExist,
delete_active_wishlist, self.request)
wishlist = get_or_create_wishlist(self.request)
wishlist.add_product(self.product)
self.assertEqual(
WishlistItem.objects.filter(wishlist=wishlist).count(), 1)
self.assertEqual(Wishlist.objects.all().count(), 1)
request = Mock()
setattr(request, 'user', self.user)
setattr(request, 'session', {'active_wishlist': wishlist.id})
delete_active_wishlist(request)
self.assertFalse(hasattr(request, '_wishlist'))
self.assertFalse(request.session.has_key('active_wishlist'))
self.assertEqual(Wishlist.objects.all().count(), 0)
# check for automatic delete cascade
self.assertEqual(
WishlistItem.objects.filter(wishlist=wishlist).count(), 0)
get_or_create_wishlist(request)
self.assertEqual(Wishlist.objects.all().count(), 1)
delete_active_wishlist(request)
self.assertEqual(Wishlist.objects.all().count(), 0)
def test_tag_select_wishlist(self):
"""Create a select field with all wishlists"""
get_or_create_wishlist(self.request)
wishlist = create_additional_wishlist(self.request)
context = {'request': self.request}
select_wishlist(context)
self.assertEqual(len(context['wishlists']), 2)
self.assertEqual(context['active_wishlist'],
self.request.session['active_wishlist'])
self.assertEqual(context['active_wishlist'], wishlist.id)
class WishlistsTest(TestCase):
def setUp(self):
self.request = Mock()
setattr(self.request, 'session', {})
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
setattr(self.request, 'user', self.user)
def test_get_templates_return_expected_values(self):
view = DiaryDetailView()
setattr(view, 'object', None)
tmp = view.get_template_names()
self.assertGreaterEqual(len(tmp), 1)
def test_no_wishlist_for_anonymous_user(self):
"""Wishlists for anonymous users are not allowed"""
setattr(self.request, 'user', None)
self.assertRaises(exceptions.PermissionDenied, get_or_create_wishlist, self.request)
self.assertRaises(exceptions.PermissionDenied, create_additional_wishlist, self.request)
def test_create_wishlist(self):
"""Asking for a wishlist twice, shall create only one"""
wishlist = get_or_create_wishlist(self.request)
# check that wishlist is stored in request
self.assertEqual(wishlist, get_or_create_wishlist(self.request))
self.assertTrue(hasattr(self.request, '_wishlist'))
self.assertTrue(self.request.session.has_key('active_wishlist'))
# check that wishlist is stored in session
request = Mock()
setattr(request, 'session', {'active_wishlist': wishlist.id})
setattr(request, 'user', self.user)
self.assertEqual(wishlist, get_or_create_wishlist(request))
# check that wishlist is stored for current user
request = Mock()
setattr(request, 'session', {})
setattr(request, 'user', self.user)
self.assertEqual(wishlist, get_or_create_wishlist(request))
self.assertEqual(request.session['active_wishlist'], wishlist.id)
self.assertEqual(request._wishlist, wishlist)
def test_do_not_share_wishlists(self):
""""Different users shall never share a wishlist"""
wishlist = get_or_create_wishlist(self.request)
request = Mock()
setattr(request, 'session', {})
user2 = User.objects.create(username="******", email="*****@*****.**",
first_name="Test2", last_name="Tester2")
setattr(request, 'user', user2)
self.assertNotEqual(wishlist, get_or_create_wishlist(request))
def test_is_product_on_active_wishlist(self):
"""A product IS on the wishlist independently of its variation"""
wishlist = get_or_create_wishlist(self.request)
variation1 = {'foo': 'bar'}
variation2 = {'foo': 'baz'}
wishlist.add_product(self.product, variation=variation1)
wishlist.add_product(self.product, variation=variation2)
self.assertTrue(is_product_on_active_wishlist(self.request, self.product))
items = wishlist.get_all_items()
self.assertEqual(len(items), 2)
wishlist.delete_item(items[0].id)
self.assertEqual(len(wishlist.get_all_items()), 1)
self.assertTrue(is_product_on_active_wishlist(self.request, self.product))
wishlist.delete_item(items[1].id)
self.assertFalse(is_product_on_active_wishlist(self.request, self.product))
def test_find_product_on_active_wishlist(self):
"""Products added to the wishlist must be found again"""
wishlist = get_or_create_wishlist(self.request)
variation = {'foo': 'bar'}
wishlist.add_product(self.product, variation=variation)
self.assertEqual(len(wishlist.get_all_items()), 1)
items = wishlist.find_item(self.product)
self.assertEqual(len(items), 0)
items = wishlist.find_item(self.product, variation=variation)
self.assertEqual(len(items), 1)
wishlist.add_product(self.product, variation={'foo': 'baz'})
self.assertEqual(len(wishlist.get_all_items()), 2)
wishlist.add_product(self.product)
self.assertEqual(len(wishlist.get_all_items()), 3)
def test_copy_product_to_cart(self):
"""Products added to the wishlist must be transferable to the cart"""
wishlist = get_or_create_wishlist(self.request)
variation = {'foo': 'bar'}
wishlist.add_product(self.product, variation=variation)
self.assertEqual(len(wishlist.get_all_items()), 1)
item = wishlist.get_all_items()[0]
copy_item_to_cart(self.request, item.id)
cart = get_or_create_cart(self.request)
cart_item = CartItem.objects.all()[0]
self.assertEqual(self.product, cart_item.product)
self.assertEqual(variation, cart_item.variation)
def test_create_additional_wishlist(self):
get_or_create_wishlist(self.request)
self.assertEqual(Wishlist.objects.all().count(), 1)
wishlist = create_additional_wishlist(self.request)
self.assertEqual(Wishlist.objects.all().count(), 2)
self.assertEqual(self.request._wishlist, wishlist)
self.assertEqual(self.request.session['active_wishlist'], wishlist.id)
self.assertEqual(self.request._wishlist, wishlist)
def test_switch_wishlist(self):
self.assertRaises(exceptions.ObjectDoesNotExist, switch_wishlist, self.request, 987)
wishlist1 = get_or_create_wishlist(self.request)
wishlist2 = create_additional_wishlist(self.request)
self.assertEqual(self.request.session['active_wishlist'], wishlist2.id)
self.assertEqual(self.request._wishlist, wishlist2)
switch_wishlist(self.request, wishlist1.id)
self.assertEqual(self.request.session['active_wishlist'], wishlist1.id)
self.assertEqual(self.request._wishlist, wishlist1)
def test_rename_wishlist(self):
"""Products added to the wishlist must be found again"""
self.assertRaises(exceptions.ObjectDoesNotExist, rename_active_wishlist, self.request, 'DEF')
wishlist = get_or_create_wishlist(self.request)
self.assertEqual(wishlist.name, _('My wishlist'))
rename_active_wishlist(self.request, 'ABC')
self.assertEqual(wishlist.name, 'ABC')
request = Mock()
setattr(request, 'user', self.user)
setattr(request, 'session', {'active_wishlist': wishlist.id})
rename_active_wishlist(request, 'DEF')
wishlist = get_or_create_wishlist(request)
self.assertEqual(wishlist.name, 'DEF')
def test_delete_wishlist(self):
"""Deleting a wishlist also deletes all its items"""
self.assertRaises(exceptions.ObjectDoesNotExist, delete_active_wishlist, self.request)
wishlist = get_or_create_wishlist(self.request)
wishlist.add_product(self.product)
self.assertEqual(WishlistItem.objects.filter(wishlist=wishlist).count(), 1)
self.assertEqual(Wishlist.objects.all().count(), 1)
request = Mock()
setattr(request, 'user', self.user)
setattr(request, 'session', {'active_wishlist': wishlist.id})
delete_active_wishlist(request)
self.assertFalse(hasattr(request, '_wishlist'))
self.assertFalse(request.session.has_key('active_wishlist'))
self.assertEqual(Wishlist.objects.all().count(), 0)
# check for automatic delete cascade
self.assertEqual(WishlistItem.objects.filter(wishlist=wishlist).count(), 0)
get_or_create_wishlist(request)
self.assertEqual(Wishlist.objects.all().count(), 1)
delete_active_wishlist(request)
self.assertEqual(Wishlist.objects.all().count(), 0)
def test_tag_select_wishlist(self):
"""Create a select field with all wishlists"""
get_or_create_wishlist(self.request)
wishlist = create_additional_wishlist(self.request)
context = { 'request': self.request }
select_wishlist(context)
self.assertEqual(len(context['wishlists']), 2)
self.assertEqual(context['active_wishlist'], self.request.session['active_wishlist'])
self.assertEqual(context['active_wishlist'], wishlist.id)
class ProductVariationsTest(TestCase):
def setUp(self):
"""Sets up the TestModel."""
self._create_options()
self._create_mock_diary()
self._create_mock_calendar()
self.user = User.objects.create(username="******",
email="*****@*****.**",
first_name="Test",
last_name="Tester")
def test_get_product_returns_correctly(self):
request = Mock()
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
setattr(view, 'object', None)
obj = view.get_object()
self.assertTrue(isinstance(obj, DiaryProduct))
def test_get_templates_return_expected_values(self):
view = DiaryDetailView()
setattr(view, 'object', None)
tmp = view.get_template_names()
self.assertGreaterEqual(len(tmp), 1)
def test_add_diary_to_cart_using_post(self):
# create form data with a product containing variations and simulate POST
post = {
'product_action': 'add_to_cart',
'add_item_id': self.diary.id,
'add_item_quantity': 1,
'add_item_option_group_1': 2, # Color: green
'add_item_text_option_1': 'Doctor Diary', # Engraving
}
request = self._get_post_request(post)
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
view.post()
ret = self._get_from_cart()
# check if the product is in the cart
self.assertEqual(len(ret['cart_items']), 1)
values = ret['cart_items'].values()[0]
self.assertEqual(values['product_id'], self.diary.id)
self.assertEqual(values['quantity'], 1)
variation = json.loads(values['variation'])
self.assertEqual(variation['option_groups']['1']['name'], 'Color')
self.assertEqual(variation['option_groups']['1']['option']['name'], 'green')
self.assertEqual(variation['text_options']['1']['text'], 'Doctor Diary')
# add the same product with missing quantity field
del post['add_item_quantity']
request = self._get_post_request(post)
view = DiaryDetailView(request=request, kwargs={'pk': self.diary.id})
view.post()
ret = self._get_from_cart()
values = ret['cart_items'].values()[0]
self.assertEqual(values['quantity'], 2)
def test_add_calendar_to_cart_using_post(self):
# create form data with a product containing variations and simulate POST
post = {
'product_action': 'add_to_cart',
'add_item_id': self.calendar.id,
'add_item_quantity': 1,
'add_item_option_group_1': 1, # Color: red
}
request = self._get_post_request(post)
view = CalendarDetailView(request=request, kwargs={'pk': self.calendar.id})
setattr(view, 'object', None)
view.post()
ret = self._get_from_cart()
# check if the product is in the cart
self.assertEqual(len(ret['cart_items']), 1)
values = ret['cart_items'].values()[0]
self.assertEqual(values['product_id'], self.calendar.id)
self.assertEqual(values['quantity'], 1)
variation = json.loads(values['variation'])
self.assertEqual(variation['option_groups']['1']['name'], 'Color')
self.assertEqual(variation['option_groups']['1']['option']['name'], 'red')
self.assertFalse('text_options' in variation)
def _get_post_request(self, post):
request = Mock()
setattr(request, 'is_ajax', lambda: False)
setattr(request, 'user', self.user)
setattr(request, 'POST', post)
return request
def _get_from_cart(self):
request = Mock()
setattr(request, 'user', self.user)
view = CartDetails(request=request)
ret = view.get_context_data()
self.assertNotEqual(ret, None)
return ret
def _create_options(self):
option_group = OptionGroup(name='Color', slug='color')
option_group.save()
price = Decimal('1.25')
Option(name='red', price=price, group=option_group).save()
Option(name='green', price=price, group=option_group).save()
Option(name='blue', price=price, group=option_group).save()
TextOption(name='Engraving', price=price, max_length=12).save()
def _create_mock_diary(self):
self.diary = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.diary.name = 'Diary'
self.diary.slug = 'mock-diary'
self.diary.short_description = 'test'
self.diary.long_description = 'test'
self.diary.unit_price = Decimal('1.0')
self.diary.save()
options_group = OptionGroup.objects.all()[0]
self.diary.options_groups.add(options_group)
text_options = TextOption.objects.all()[0]
self.diary.text_options.add(text_options)
def _create_mock_calendar(self):
self.calendar = CalendarProduct(isbn='1234567890', number_of_pages=100)
self.calendar.name = 'Calendar'
self.calendar.slug = 'mock-calendar'
self.calendar.short_description = 'test'
self.calendar.long_description = 'test'
self.calendar.unit_price = Decimal('1.0')
self.calendar.save()
options_group = OptionGroup.objects.all()[0]
self.calendar.options_groups.add(options_group)
class IPaymentTest(LiveServerTestCase):
def setUp(self):
current_site = Site.objects.get(id=settings.SITE_ID)
current_site.domain = settings.HOST_NAME
current_site.save()
self._create_fake_order()
self.ipayment_backend = backends_pool.get_payment_backends_list()[0]
self.factory = RequestFactory()
self.request = Mock()
setattr(self.request, 'session', {})
setattr(self.request, 'is_secure', lambda: False)
user = User.objects.create(username="******", email="*****@*****.**",
first_name="Test", last_name="Tester",
password="******")
setattr(self.request, 'user', user)
self.country_usa = Country(name='USA')
self.country_usa.save()
self.client = Client()
self.client.login(username='******', password='******')
self._create_cart()
self._go_shopping()
def tearDown(self):
time.sleep(10) # this keeps the server running for a while
def _create_cart(self):
self.product = DiaryProduct(isbn='1234567890', number_of_pages=100)
self.product.name = 'test'
self.product.slug = 'test'
self.product.short_description = 'test'
self.product.long_description = 'test'
self.product.unit_price = Decimal('1.0')
self.product.save()
self.cart = get_or_create_cart(self.request)
self.cart.add_product(self.product, 1)
self.cart.save()
def _go_shopping(self):
# add address information
post = {
'ship-name': 'John Doe',
'ship-address': 'Rosestreet',
'ship-address2': '',
'ship-zip_code': '01234',
'ship-city': 'Toledeo',
'ship-state': 'Ohio',
'ship-country': self.country_usa.pk,
'bill-name': 'John Doe',
'bill-address': 'Rosestreet',
'bill-address2': '',
'bill-zip_code': '01234',
'bill-city': 'Toledeo',
'bill-state': 'Ohio',
'bill-country': self.country_usa.pk,
'shipping_method': 'flat',
'payment_method': 'ipayment',
}
response = self.client.post(reverse('checkout_selection'), post, follow=True)
urlobj = urlparse.urlparse(response.redirect_chain[0][0])
self.assertEqual(resolve(urlobj.path).url_name, 'checkout_shipping')
urlobj = urlparse.urlparse(response.redirect_chain[1][0])
self.assertEqual(resolve(urlobj.path).url_name, 'flat')
self.order = self.ipayment_backend.shop.get_order(self.request)
def _simulate_payment(self):
"""
Simulate a payment to the IPayment processor.
The full payment information is sent with method POST. Make sure your
test environment is reachable from the Internet. This test will
a) invoke a POST request from IPayment to this server
b) redirect the client to a given URL on this server
Both actions shall result in the confirmation of the payment.
"""
post = self.ipayment_backend.get_hidden_context(self.order)
post['advanced_strict_id_check'] = 0 # disabled for testing only
# (see ipayment_Technik-Handbuch.pdf page 32)
if settings.IPAYMENT['useSessionId']:
post['ipayment_session_id'] = self.ipayment_backend.get_session_id(self.request, self.order)
else:
post.update(self.ipayment_backend.get_sessionless_context(self.request, self.order))
post['trx_securityhash'] = self.ipayment_backend._calc_trx_security_hash(post)
post.update({
'addr_name': 'John Doe',
'cc_number': '4012888888881881', # Visa test credit card number
'cc_checkcode': '123',
'cc_expdate_month': '12',
'cc_expdate_year': '2029',
})
ipayment_uri = '/merchant/%s/processor/2.0/' % settings.IPAYMENT['accountId']
headers = {
"Content-type": "application/x-www-form-urlencoded",
"Accept": "text/plain"
}
conn = httplib.HTTPSConnection('ipayment.de')
conn.request("POST", ipayment_uri, urllib.urlencode(post), headers)
httpresp = conn.getresponse()
self.assertEqual(httpresp.status, 302, 'Expected to be redirected back from IPayment')
redir_url = urlparse.urlparse(httpresp.getheader('location'))
query_params = urlparse.parse_qs(redir_url.query)
redir_uri = redir_url.path + '?' + redir_url.query
conn.close()
self.assertEqual(query_params['ret_status'][0], 'SUCCESS', 'IPayment reported: ' + redir_uri)
# IPayent redirected the customer onto 'redir_uri'. Continue to complete the order.
response = self.client.get(redir_uri, follow=True)
self.assertEqual(len(response.redirect_chain), 1, '')
urlobj = urlparse.urlparse(response.redirect_chain[0][0])
self.assertEqual(resolve(urlobj.path).url_name, 'thank_you_for_your_order')
self.assertEqual(response.status_code, 200)
order = Order.objects.get(pk=self.order.id)
self.assertEqual(order.status, Order.COMPLETED)
confirmation = Confirmation.objects.get(shopper_id=self.order.id)
self.assertEqual(confirmation.ret_status, 'SUCCESS')
def _create_fake_order(self):
"""
Create a fake order with a random order id, so that the following real
order does not start with 1. Otherwise this could cause errors if this
test is invoked multiple times.
"""
order_id = random.randint(100001, 999999)
Order.objects.create(id=order_id, status=Order.CANCELLED)
def test_without_session(self):
"""
Simulate a payment to the IPayment processor without using a session.
"""
setattr(settings, 'IPAYMENT', settings.IPAYMENT_WITHOUT_SESSION)
self._simulate_payment()
def test_with_session(self):
"""
Simulate a payment to the IPayment processor using a session id generated
through a SOAP invocation.
"""
setattr(settings, 'IPAYMENT', settings.IPAYMENT_WITH_SESSION)
self._simulate_payment()
