def setUp(self):
self.factory = test.RequestFactory()
from django.contrib.sessions.backends.file import SessionStore
store = SessionStore()
store.save()
self.session = store
def setUp(self):
self.factory = test.RequestFactory()
from django.contrib.sessions.backends.file import SessionStore
store = SessionStore()
store.save()
self.session = store
class AddedToCartTestCase(TestCase):
"""
"""
fixtures = ["lfs_shop.xml"]
def setUp(self):
"""
"""
self.p1 = Product.objects.create(
name="Product 1", slug="product-1", price=10.0, active=True, manage_stock_amount=False
)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1, max=2, unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_totals_1(self):
"""Add a product without quantity to cart (implicit 1)
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, "en_US.UTF-8")
# Added product_1 to cart
add_to_cart(request)
response = added_to_cart_items(request)
# need to test for two versions of currency output (Mac and Ubuntu differ)
self.failIf(response.find(u"Total: $10.00") == -1)
# Added product_1 to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $20.00") == -1)
def test_totals_2(self):
"""Add a product with explicit quantity to cart
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, "en_US.UTF-8")
# Added product_1 two times to cart
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $20.00") == -1)
# Added product_1 two times to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $40.00") == -1)
def setUp(self):
"""
"""
session = SessionStore()
session.save()
rf = RequestFactory()
self.request = rf.get('/')
self.request.session = session
self.request.user = AnonymousUser()
tax = Tax.objects.create(rate=19)
shipping_method = ShippingMethod.objects.create(
name="Standard",
active=True,
price=1.0,
tax=tax
)
payment_method = PaymentMethod.objects.create(
name="Direct Debit",
active=True,
tax=tax,
)
us = Country.objects.get(code="us")
ie = Country.objects.get(code="ie")
address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
phone="555-111111",
email="*****@*****.**",
)
address2 = Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
phone="666-111111",
email="*****@*****.**",
)
address3 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
phone="555-111111",
email="*****@*****.**",
)
address4 = Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
phone="666-111111",
email="*****@*****.**",
)
self.customer = Customer.objects.create(
session=session.session_key,
selected_shipping_method=shipping_method,
selected_payment_method=payment_method,
selected_shipping_address=address1,
selected_invoice_address=address2,
default_shipping_address=address1,
default_invoice_address=address2,
)
self.p1 = Product.objects.create(
name="Product 1",
slug="product-1",
sku="sku-1",
price=1.1,
tax=tax,
active=True,
)
self.p2 = Product.objects.create(
name="Product 2",
slug="product-2",
sku="sku-2",
price=2.2,
tax=tax,
active=True,
)
cart = Cart.objects.create(
session=session.session_key
)
item = CartItem.objects.create(
cart=cart,
product=self.p1,
amount=2,
)
item = CartItem.objects.create(
cart=cart,
product=self.p2,
amount=3,
)
def setUp(self):
"""
"""
session = SessionStore()
session.save()
rf = RequestFactory()
self.request = rf.get('/')
self.request.session = session
self.request.user = AnonymousUser()
tax = Tax.objects.create(rate=19)
delivery_time = DeliveryTime.objects.create(min=3, max=10)
shipping_method = ShippingMethod.objects.create(
name="Standard",
active=True,
price=1.0,
tax=tax,
delivery_time=delivery_time)
payment_method = PaymentMethod.objects.create(
name="Direct Debit",
active=True,
tax=tax,
)
us = Country.objects.get(code="us")
ie = Country.objects.get(code="ie")
address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
phone="555-111111",
email="*****@*****.**",
)
address2 = Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
phone="666-111111",
email="*****@*****.**",
)
Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
phone="555-111111",
email="*****@*****.**",
)
Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
phone="666-111111",
email="*****@*****.**",
)
self.customer = Customer.objects.create(
session=session.session_key,
selected_shipping_method=shipping_method,
selected_payment_method=payment_method,
selected_shipping_address=address1,
selected_invoice_address=address2,
default_shipping_address=address1,
default_invoice_address=address2,
)
self.p1 = Product.objects.create(
name="Product 1",
slug="product-1",
sku="sku-1",
price=1.1,
tax=tax,
active=True,
)
self.p2 = Product.objects.create(
name="Product 2",
slug="product-2",
sku="sku-2",
price=2.2,
tax=tax,
active=True,
)
cart = Cart.objects.create(session=session.session_key)
CartItem.objects.create(
cart=cart,
product=self.p1,
amount=2,
)
CartItem.objects.create(
cart=cart,
product=self.p2,
amount=3,
)
class AddedToCartTestCase(TestCase):
"""
"""
fixtures = ['lfs_shop.xml']
def setUp(self):
"""
"""
self.p1 = Product.objects.create(name="Product 1",
slug="product-1",
price=10.0,
active=True,
manage_stock_amount=False)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1,
max=2,
unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_totals_1(self):
"""Add a product without quantity to cart (implicit 1)
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 to cart
add_to_cart(request)
response = added_to_cart_items(request)
# need to test for two versions of currency output (Mac and Ubuntu differ)
self.failIf(response.find(u"Total: $10.00") == -1)
# Added product_1 to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $20.00") == -1)
def test_totals_2(self):
"""Add a product with explicit quantity to cart
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 two times to cart
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $20.00") == -1)
# Added product_1 two times to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u"Total: $40.00") == -1)
class RefreshCartTestCase(TestCase):
"""Test case for refresh_cart view.
"""
fixtures = ['lfs_shop.xml']
def setUp(self):
"""
"""
self.p1 = Product.objects.create(name="Product 1",
slug="product-1",
price=10.0,
active=True)
self.dt = DeliveryTime.objects.create(min=1,
max=2,
unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_amount_1(self):
"""Don't manage stock amount.
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Refresh item amount
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 2
})
request.session = self.session
request.user = self.user
refresh_cart(request)
self.assertEqual(cart.get_amount_of_items(), 2.0)
def test_amount_2(self):
"""Manage stock amount; refresh to 2 only 1 products there.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Try to increase item to two, but there is only one in stock
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 2
})
request.session = self.session
request.user = self.user
# This results into a message to the customer
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(
result.get("message"),
"Sorry, but \'Product 1\' is only one time available.")
# And the amount of the item is still 1.0
self.assertEqual(cart.get_amount_of_items(), 1.0)
# If the product is ordered the customer can add it into cart again
self.p1.order_time = self.dt
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
# Or if LFS not managing stock amount the product can be added to the cart
self.p1.order_time = None
self.p1.manage_stock_amount = False
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
def test_amount_3(self):
"""Manage stock amount; refresh to 3 only 2 products there.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 2
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Increase items to two
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 2
})
request.session = self.session
request.user = self.user
# Refresh to amount of two is possible
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
# Try to increase item to 3, but there are only 2 in stock
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 3
})
request.session = self.session
request.user = self.user
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(
result.get("message"),
"Sorry, but \'Product 1\' is only 2.0 times available.")
# And the amount of the item is still 2.0
self.assertEqual(cart.get_amount_of_items(), 2.0)
# If the product is ordered the customer can add it into cart again
self.p1.order_time = self.dt
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 3.0)
# Or if LFS not managing stock amount the product can be added to the cart
self.p1.order_time = None
self.p1.manage_stock_amount = False
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 3.0)
def test_amount_4(self):
"""Manage stock amount; refresh to 2 but no product is there anymore.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
self.p1.stock_amount = 0
self.p1.save()
# Try to increase item to two, but there is no product in stock anymore
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 2
})
request.session = self.session
request.user = self.user
# Refresh to amount of two is not possible
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"),
"Sorry, but 'Product 1' is not available anymore.")
self.assertEqual(cart.get_amount_of_items(), 0.0)
class AddToCartTestCase(TestCase):
"""Test case for add_to_cart view.
"""
fixtures = ['lfs_shop.xml']
def setUp(self):
"""
"""
self.p1 = Product.objects.create(name="Product 1",
slug="product-1",
price=10.0)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1,
max=2,
unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_add_to_cart_non_active(self):
"""Try to add product to the cart which is not active.
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
self.assertRaises(Http404, add_to_cart, request, self.p1.id)
def test_add_to_cart_not_deliverable(self):
"""Try to add product to the cart which is not deliverable.
"""
self.p1.active = True
self.p1.deliverable = False
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Not deliverable
self.assertRaises(Http404, add_to_cart, request, self.p1.id)
def test_add_to_cart_not_in_stock(self):
"""Try to add product to the cart which is not in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 0
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
self.assertRaises(Http404, add_to_cart, request)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
def test_add_to_cart_stock_1(self):
"""Try to add product two times to cart if only one is in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
# This need to result in a message to the customer
result = add_to_cart(request)
self.failIf(
result.cookies.get("message").__str__().find(
"Sorry%2C%20but%20%27Product%201%27%20is%20only%20one%20time%20available."
) == -1)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
def test_add_to_cart_stock_2(self):
"""Try to add product three times to cart if only two is in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 2
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 3})
request.session = self.session
request.user = self.user
# This need to result in a message to the customer
result = add_to_cart(request)
self.failIf(
result.cookies.get("message").__str__().find(
"Sorry%2C%20but%20%27Product%201%27%20is%20only%202.0%20times%20available."
) == -1)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
class AddedToCartTestCase(TestCase):
"""
"""
fixtures = ['lfs_shop.xml']
def setUp(self):
"""
"""
from lfs.customer.models import Customer
from lfs.addresses.models import Address
from lfs.shipping.models import ShippingMethod
from lfs.payment.models import PaymentMethod
from lfs.core.models import Country
self.p1 = Product.objects.create(name="Product 1",
slug="product-1",
price=10.0,
active=True,
manage_stock_amount=False)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1,
max=2,
unit=DELIVERY_TIME_UNIT_DAYS)
self.session = SessionStore()
self.session.save()
self.username = '******'
self.password = '******'
self.user = User.objects.create(username=self.username)
self.user.set_password(self.password)
self.user.save()
tax = Tax.objects.create(rate=19)
de = Country.objects.get(code="de")
shipping_method = ShippingMethod.objects.create(name="Standard",
active=True,
price=1.0,
tax=tax)
payment_method = PaymentMethod.objects.create(
name="Direct Debit",
active=True,
tax=tax,
)
self.address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="23422",
country=de,
phone="555-111111",
email="*****@*****.**",
)
address_1_id = self.address1.pk
self.address1.pk = None
self.address2 = self.address1.save()
self.address1.pk = None
self.address3 = self.address1.save()
self.address1.pk = None
self.address4 = self.address1.save()
self.address1 = Address.objects.get(pk=address_1_id)
self.customer = Customer.objects.create(
user=self.user,
selected_shipping_method=shipping_method,
selected_payment_method=payment_method,
selected_shipping_address=self.address1,
selected_invoice_address=self.address2,
default_shipping_address=self.address3,
default_invoice_address=self.address4,
)
def test_totals_1(self):
"""Add a product without quantity to cart (implicit 1)
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 to cart
add_to_cart(request)
response = added_to_cart_items(request)
# need to test for two versions of currency output (Mac and Ubuntu differ)
self.failIf(
response.find(u'Total: <span class="money">$10.00</span>') == -1)
# Added product_1 to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(
response.find(u'Total: <span class="money">$20.00</span>') == -1)
def test_totals_2(self):
"""Add a product with explicit quantity to cart
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 two times to cart
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(
response.find(u'Total: <span class="money">$20.00</span>') == -1)
# Added product_1 two times to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(
response.find(u'Total: <span class="money">$40.00</span>') == -1)
def test_discounts(self):
"""Add a product with explicit quantity to cart and use discounts/voucher
Discount 'Summer' and Voucher are able to sum up while discount 'Special offer 1' cannot be summed up.
Value of summed up 'Summer' and Voucher is bigger than 'Special offer 1' so these two should be used
"""
from lfs.discounts.models import Discount
from lfs.discounts.settings import DISCOUNT_TYPE_ABSOLUTE
tax = Tax.objects.create(rate=19)
Discount.objects.create(name="Summer",
active=True,
value=3.0,
type=DISCOUNT_TYPE_ABSOLUTE,
tax=tax,
sums_up=True)
discount_value = 2.0
Discount.objects.create(name="Special offer 1",
active=True,
value=discount_value,
type=DISCOUNT_TYPE_ABSOLUTE,
tax=tax,
sums_up=False)
# vouchers
from lfs.voucher.models import VoucherGroup, Voucher
from lfs.voucher.settings import ABSOLUTE
user = User.objects.get(username=self.username)
self.vg = VoucherGroup.objects.create(name="xmas", creator=user)
voucher_value = 1.0
self.v1 = Voucher.objects.create(
number="AAAA",
group=self.vg,
creator=user,
start_date=datetime.date.today() + datetime.timedelta(days=-10),
end_date=datetime.date.today() + datetime.timedelta(days=10),
effective_from=0,
kind_of=ABSOLUTE,
value=voucher_value,
sums_up=True,
limit=2,
tax=tax)
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
add_to_cart(request)
self.client.login(username=self.username, password=self.password)
response = self.client.post(reverse('lfs_cart'),
data={'voucher': self.v1.number})
self.assertNotContains(response, 'Special offer 1')
self.assertContains(response, 'Summer')
self.assertContains(response, 'Voucher')
self.assertContains(response, 'The voucher is valid')
def setUp(self):
self.factory = test.RequestFactory()
store = SessionStore()
store.save()
self.session = store
class RefreshCartTestCase(TestCase):
"""Test case for refresh_cart view.
"""
fixtures = ["lfs_shop.xml"]
def setUp(self):
"""
"""
self.p1 = Product.objects.create(name="Product 1", slug="product-1", price=10.0, active=True)
self.dt = DeliveryTime.objects.create(min=1, max=2, unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_amount_1(self):
"""Don't manage stock amount.
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Refresh item amount
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 2})
request.session = self.session
request.user = self.user
refresh_cart(request)
self.assertEqual(cart.get_amount_of_items(), 2.0)
def test_amount_2(self):
"""Manage stock amount; refresh to 2 only 1 products there.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Try to increase item to two, but there is only one in stock
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 2})
request.session = self.session
request.user = self.user
# This results into a message to the customer
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "Sorry, but 'Product 1' is only one time available.")
# And the amount of the item is still 1.0
self.assertEqual(cart.get_amount_of_items(), 1.0)
# If the product is ordered the customer can add it into cart again
self.p1.order_time = self.dt
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
# Or if LFS not managing stock amount the product can be added to the cart
self.p1.order_time = None
self.p1.manage_stock_amount = False
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
def test_amount_3(self):
"""Manage stock amount; refresh to 3 only 2 products there.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 2
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
# Increase items to two
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 2})
request.session = self.session
request.user = self.user
# Refresh to amount of two is possible
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
# Try to increase item to 3, but there are only 2 in stock
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 3})
request.session = self.session
request.user = self.user
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "Sorry, but 'Product 1' is only 2.0 times available.")
# And the amount of the item is still 2.0
self.assertEqual(cart.get_amount_of_items(), 2.0)
# If the product is ordered the customer can add it into cart again
self.p1.order_time = self.dt
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 3.0)
# Or if LFS not managing stock amount the product can be added to the cart
self.p1.order_time = None
self.p1.manage_stock_amount = False
self.p1.save()
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 3.0)
def test_amount_4(self):
"""Manage stock amount; refresh to 2 but no product is there anymore.
"""
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Add product to cart
result = add_to_cart(request)
cart = lfs.cart.utils.get_cart(request)
self.assertEqual(cart.get_amount_of_items(), 1.0)
self.p1.stock_amount = 0
self.p1.save()
# Try to increase item to two, but there is no product in stock anymore
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 2})
request.session = self.session
request.user = self.user
# Refresh to amount of two is not possible
result = simplejson.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "Sorry, but 'Product 1' is not available anymore.")
self.assertEqual(cart.get_amount_of_items(), 0.0)
class AddToCartTestCase(TestCase):
"""Test case for add_to_cart view.
"""
fixtures = ["lfs_shop.xml"]
def setUp(self):
"""
"""
self.p1 = Product.objects.create(name="Product 1", slug="product-1", price=10.0)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1, max=2, unit=DELIVERY_TIME_UNIT_DAYS)
self.user = User.objects.create(username="******")
self.session = SessionStore()
self.session.save()
def test_add_to_cart_non_active(self):
"""Try to add product to the cart which is not active.
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
self.assertRaises(Http404, add_to_cart, request, self.p1.id)
def test_add_to_cart_not_deliverable(self):
"""Try to add product to the cart which is not deliverable.
"""
self.p1.active = True
self.p1.deliverable = False
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1})
request.session = self.session
request.user = self.user
# Not deliverable
self.assertRaises(Http404, add_to_cart, request, self.p1.id)
def test_add_to_cart_not_in_stock(self):
"""Try to add product to the cart which is not in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 0
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
self.assertRaises(Http404, add_to_cart, request)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
def test_add_to_cart_stock_1(self):
"""Try to add product two times to cart if only one is in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 1
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
# This need to result in a message to the customer
result = add_to_cart(request)
self.failIf(
result.cookies.get("message")
.__str__()
.find("Sorry%2C%20but%20%27Product%201%27%20is%20only%20one%20time%20available.")
== -1
)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
def test_add_to_cart_stock_2(self):
"""Try to add product three times to cart if only two is in stock.
"""
self.p1.active = True
self.p1.deliverable = True
self.p1.manage_stock_amount = True
self.p1.stock_amount = 2
self.p1.save()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 3})
request.session = self.session
request.user = self.user
# This need to result in a message to the customer
result = add_to_cart(request)
self.failIf(
result.cookies.get("message")
.__str__()
.find("Sorry%2C%20but%20%27Product%201%27%20is%20only%202.0%20times%20available.")
== -1
)
# But no message if product is ordered ...
self.p1.order_time = self.dt
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
# ... or LFS doesn't manage stock amount
self.p1.manage_stock_amount = False
self.p1.order_time = None
self.p1.save()
result = add_to_cart(request)
self.failIf("message" in result.cookies)
class AddedToCartTestCase(TestCase):
"""
"""
fixtures = ['lfs_shop.xml']
def setUp(self):
"""
"""
from lfs.customer.models import Customer
from lfs.addresses.models import Address
from lfs.shipping.models import ShippingMethod
from lfs.payment.models import PaymentMethod
from lfs.core.models import Country
self.p1 = Product.objects.create(name="Product 1", slug="product-1", price=10.0, active=True, manage_stock_amount=False)
from django.contrib.auth.models import User
self.dt = DeliveryTime.objects.create(min=1, max=2, unit=DELIVERY_TIME_UNIT_DAYS)
self.session = SessionStore()
self.session.save()
self.username = '******'
self.password = '******'
self.user = User.objects.create(username=self.username)
self.user.set_password(self.password)
self.user.save()
tax = Tax.objects.create(rate=19)
de = Country.objects.get(code="de")
shipping_method = ShippingMethod.objects.create(
name="Standard",
active=True,
price=1.0,
tax=tax
)
payment_method = PaymentMethod.objects.create(
name="Direct Debit",
active=True,
tax=tax,
)
self.address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="23422",
country=de,
phone="555-111111",
email="*****@*****.**",
)
address_1_id = self.address1.pk
self.address1.pk = None
self.address2 = self.address1.save()
self.address1.pk = None
self.address3 = self.address1.save()
self.address1.pk = None
self.address4 = self.address1.save()
self.address1 = Address.objects.get(pk=address_1_id)
self.customer = Customer.objects.create(
user=self.user,
selected_shipping_method=shipping_method,
selected_payment_method=payment_method,
selected_shipping_address=self.address1,
selected_invoice_address=self.address2,
default_shipping_address=self.address3,
default_invoice_address=self.address4,
)
def test_totals_1(self):
"""Add a product without quantity to cart (implicit 1)
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 to cart
add_to_cart(request)
response = added_to_cart_items(request)
# need to test for two versions of currency output (Mac and Ubuntu differ)
self.failIf(response.find(u'Total: <span class="money">$10.00</span>') == -1)
# Added product_1 to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u'Total: <span class="money">$20.00</span>') == -1)
def test_totals_2(self):
"""Add a product with explicit quantity to cart
"""
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
# Added product_1 two times to cart
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u'Total: <span class="money">$20.00</span>') == -1)
# Added product_1 two times to cart again
add_to_cart(request)
response = added_to_cart_items(request)
self.failIf(response.find(u'Total: <span class="money">$40.00</span>') == -1)
def test_discounts(self):
"""Add a product with explicit quantity to cart and use discounts/voucher
Discount 'Summer' and Voucher are able to sum up while discount 'Special offer 1' cannot be summed up.
Value of summed up 'Summer' and Voucher is bigger than 'Special offer 1' so these two should be used
"""
from lfs.discounts.models import Discount
from lfs.discounts.settings import DISCOUNT_TYPE_ABSOLUTE
tax = Tax.objects.create(rate=19)
discount = Discount.objects.create(name="Summer",
active=True,
value=3.0,
type=DISCOUNT_TYPE_ABSOLUTE,
tax=tax,
sums_up=True)
discount_value = 2.0
discount = Discount.objects.create(name="Special offer 1",
active=True,
value=discount_value,
type=DISCOUNT_TYPE_ABSOLUTE,
tax=tax,
sums_up=False)
# vouchers
from lfs.voucher.models import VoucherGroup, Voucher
from lfs.voucher.settings import ABSOLUTE
user = User.objects.get(username=self.username)
self.vg = VoucherGroup.objects.create(
name="xmas",
creator=user
)
voucher_value = 1.0
self.v1 = Voucher.objects.create(
number="AAAA",
group=self.vg,
creator=user,
start_date=datetime.date.today() + datetime.timedelta(days=-10),
end_date=datetime.date.today() + datetime.timedelta(days=10),
effective_from=0,
kind_of=ABSOLUTE,
value=voucher_value,
sums_up=True,
limit=2,
tax=tax
)
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2})
request.session = self.session
request.user = self.user
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
add_to_cart(request)
self.client.login(username=self.username, password=self.password)
response = self.client.post(reverse('lfs_cart'), data={'voucher': self.v1.number})
self.assertNotContains(response, 'Special offer 1')
self.assertContains(response, 'Summer')
self.assertContains(response, 'Voucher')
self.assertContains(response, 'The voucher is valid')
def setUp(self):
"""
"""
session = SessionStore()
session.save()
rf = RequestFactory()
self.request = rf.get('/')
self.request.session = session
self.request.user = AnonymousUser()
tax = Tax.objects.create(rate=19)
discount = Discount.objects.create(name="Summer",
value=10.0,
type=0,
tax=tax)
shipping_method = ShippingMethod.objects.create(name="Standard",
active=True,
price=1.0,
tax=tax)
payment_method = PaymentMethod.objects.create(
name="Direct Debit",
active=True,
tax=tax,
)
us = Country.objects.get(code="us")
address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=us,
phone="555-111111",
email="*****@*****.**",
)
self.customer = Customer.objects.create(
session=session.session_key,
selected_shipping_method=shipping_method,
selected_payment_method=payment_method,
selected_shipping_address=address1,
selected_invoice_address=address1,
)
self.p1 = Product.objects.create(
name="Product 1",
slug="product-1",
sku="sku-1",
price=1.1,
tax=tax,
active=True,
)
self.p2 = Product.objects.create(
name="Product 2",
slug="product-2",
sku="sku-2",
price=2.2,
tax=tax,
active=True,
)
cart = Cart.objects.create(session=session.session_key)
item = CartItem.objects.create(
cart=cart,
product=self.p1,
amount=2,
)
item = CartItem.objects.create(
cart=cart,
product=self.p2,
amount=3,
)
def setUp(self):
self.factory = test.RequestFactory()
store = SessionStore()
store.save()
self.session = store
