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)
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)
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_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)
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name='pm')
sm = ShippingMethod.objects.create(name='sm')
# 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,
"shipping_method": sm.pk,
"payment_method": pm.pk
})
request.session = self.session
request.user = self.user
# This results into a message to the customer
result = json.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 = json.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 = json.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.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)
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)
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name='pm')
sm = ShippingMethod.objects.create(name='sm')
# Refresh item amount
request = rf.post(
"/", {
"product_id": self.p1.id,
"amount-cart-item_%s" % cart.get_items()[0].id: 2,
"shipping_method": sm.pk,
"payment_method": pm.pk
})
request.session = self.session
request.user = self.user
refresh_cart(request)
self.assertEqual(cart.get_amount_of_items(), 2.0)
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_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)
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_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)
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name='pm')
sm = ShippingMethod.objects.create(name='sm')
# Refresh item amount
request = rf.post("/", {"product_id": self.p1.id, "amount-cart-item_%s" % cart.get_items()[0].id: 2,
"shipping_method": sm.pk, "payment_method": pm.pk})
request.session = self.session
request.user = self.user
refresh_cart(request)
self.assertEqual(cart.get_amount_of_items(), 2.0)
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_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_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_standard_product(self):
session = SessionStore()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p0.id, "quantity": 1})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
# 1l login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(cart, None)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
# logout
session = SessionStore()
request = rf.post("/", {"product_id": self.p0.id, "quantity": 2})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
# 2. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 3)
def test_manage_urls_anonymous(self):
"""Tests that all manage urls cannot accessed by anonymous user.
"""
rf = RequestFactory()
request = rf.get("/")
request.user = AnonymousUser()
from lfs.manage.urls import urlpatterns
for url in urlpatterns:
result = url.callback(request)
self.failUnless(result["Location"].startswith("/login/?next=/"))
def test_manage_urls_anonymous(self):
"""Tests that all manage urls cannot accessed by anonymous user.
"""
rf = RequestFactory()
request = rf.get("/")
request.user = AnonymousUser()
from lfs.manage.urls import urlpatterns
for url in urlpatterns:
result = url.callback(request)
self.failUnless(result["Location"].startswith("/login/?next=/"))
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)
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name='pm')
sm = ShippingMethod.objects.create(name='sm')
# 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,
"shipping_method": sm.pk, "payment_method": pm.pk})
request.session = self.session
request.user = self.user
# This results into a message to the customer
result = json.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 = json.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 = json.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 2.0)
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_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_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)
item_id = cart.get_items()[0].id
self.p1.stock_amount = 0
self.p1.save()
self.assertEqual(0, len(cart.get_items()))
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name="pm")
sm = ShippingMethod.objects.create(name="sm")
# 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" % item_id: 2,
"shipping_method": sm.pk,
"payment_method": pm.pk,
},
)
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(cart.get_amount_of_items(), 0.0)
self.assertTrue("Your Cart is empty" in result.get("html"))
def test_ga_ecommerce_tracking(self):
"""
"""
shop = lfs.core.utils.get_default_shop()
shop.google_analytics_id = ""
shop.ga_site_tracking = False
shop.ga_ecommerce_tracking = False
shop.save()
session = SessionStore()
rf = RequestFactory()
request = rf.get('/')
request.session = session
template = get_template_from_string(
"""{% load lfs_tags %}{% google_analytics_ecommerce %}""")
content = template.render(Context({"request": request}))
self.failIf(content.find("pageTracker") != -1)
# Enter a google_analytics_id
shop.google_analytics_id = "UA-XXXXXXXXXX"
shop.save()
# Simulating a new request
rf = RequestFactory()
request = rf.get('/')
request.session = session
# But this is not enough
content = template.render(Context({"request": request}))
self.failIf(content.find("pageTracker") != -1)
# It has to be activated first
shop.ga_ecommerce_tracking = True
shop.save()
# Simulating a new request
rf = RequestFactory()
request = rf.get('/')
request.session = session
# But this is still not enough
content = template.render(Context({"request": request}))
self.failIf(content.find("pageTracker") != -1)
# There has to be an order within the session
session["order"] = Order()
# Now it works and "pageTracker" is found
content = template.render(Context({"request": request}))
self.failIf(content.find("_trackPageview") == -1)
def setUp(self):
"""
"""
self.request = RequestFactory().get("/")
self.request.session = SessionStore()
self.request.user = User(id=1)
self.vg = VoucherGroup.objects.create(
name="xmas",
creator=self.request.user,
)
self.v1 = Voucher.objects.create(
number="AAAA",
group=self.vg,
creator=self.request.user,
start_date=datetime.date(2009, 12, 1),
end_date=datetime.date(2009, 12, 31),
effective_from=0,
kind_of=ABSOLUTE,
value=10.0,
limit=2,
)
self.p1 = Product.objects.create(name="Product 1", slug="product-1", price=10.0, active=True)
self.p2 = Product.objects.create(name="Product 2", slug="product-2", price=100.0, active=True)
self.cart = Cart.objects.create()
CartItem.objects.create(cart=self.cart, product=self.p1, amount=1)
CartItem.objects.create(cart=self.cart, product=self.p2, amount=1)
def setUp(self):
"""
"""
self.request = RequestFactory().get("/")
self.request.session = SessionStore()
self.request.user = User(id=1)
self.tax = Tax.objects.create(rate=19.0)
self.p1 = Product.objects.create(name="Product 1",
slug="product-1",
price=10.0,
tax=self.tax,
active=True)
self.p2 = Product.objects.create(name="Product 2",
slug="product-2",
price=100.0,
tax=self.tax,
active=True)
# This product is not considered as it is not active
self.p3 = Product.objects.create(name="Product 3",
slug="product-3",
price=1000.0,
tax=self.tax,
active=False)
self.cart = Cart.objects.create()
CartItem.objects.create(cart=self.cart, product=self.p1, amount=1)
CartItem.objects.create(cart=self.cart, product=self.p2, amount=1)
CartItem.objects.create(cart=self.cart, product=self.p3, amount=1)
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)
item_id = cart.get_items()[0].id
self.p1.stock_amount = 0
self.p1.save()
self.assertEqual(0, len(cart.get_items()))
# prepare shipping/payment methods
from lfs.payment.models import PaymentMethod
from lfs.shipping.models import ShippingMethod
pm = PaymentMethod.objects.create(name='pm')
sm = ShippingMethod.objects.create(name='sm')
# 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" % item_id: 2,
"shipping_method": sm.pk,
"payment_method": pm.pk
})
request.session = self.session
request.user = self.user
# Refresh to amount of two is not possible
result = json.loads(refresh_cart(request).content)
self.assertEqual(cart.get_amount_of_items(), 0.0)
self.assertTrue('Your Cart is empty' in result.get("html"))
def setUp(self):
"""
"""
shop = lfs.core.utils.get_default_shop()
shop.price_calculator = "lfs.net_price.NetPriceCalculator"
shop.save()
self.request = RequestFactory().get("/")
self.request.session = SessionStore()
# set up our price calculator
self.orig_price_calculator = lfs_settings.LFS_DEFAULT_PRICE_CALCULATOR
lfs_settings.LFS_DEFAULT_PRICE_CALCULATOR = "lfs.net_price.NetPriceCalculator"
# Create a tax
self.t1 = Tax.objects.create(rate=19.0)
# A product with properties and variants
self.p1 = Product.objects.create(
name=u"Product 1",
slug=u"product-1",
sku=u"SKU P1",
description=u"Description",
short_description=u"Short description product 1",
meta_description=u"Meta description product 1",
meta_keywords=u"Meta keywords product 1",
sub_type=PRODUCT_WITH_VARIANTS,
tax=self.t1,
price=1.0,
for_sale_price=0.5,
stock_amount=2,
width=1.0,
height=2.0,
length=3.0,
weight=4.0,
active=True)
# Products without properties and variants
self.p2 = Product.objects.create(name=u"Product 2", slug=u"product-2", active=True)
# Add a variant with color = red, size = m
self.v1 = Product.objects.create(
name=u"Variant 1",
slug=u"variant-1",
sku=u"SKU V1",
description=u"This is the description of variant 1",
meta_description=u"Meta description of variant 1",
meta_keywords=u"Meta keywords variant 1",
sub_type=VARIANT,
price=2.0,
for_sale_price=1.5,
parent=self.p1,
width=11.0,
height=12.0,
length=13.0,
weight=14.0,
active=True,
)
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 test_ga_ecommerce_tracking(self):
"""
"""
shop = Shop.objects.get(pk=1)
shop.google_analytics_id = ""
shop.ga_site_tracking = False
shop.ga_ecommerce_tracking = False
shop.save()
session = SessionStore()
rf = RequestFactory()
request = rf.get('/')
request.session = session
template = get_template_from_string(
"""{% load lfs_tags %}{% google_analytics_ecommerce %}""")
content = template.render(Context({"request" : request}))
self.failIf(content.find("pageTracker") != -1)
# Enter a google_analytics_id
shop.google_analytics_id="UA-XXXXXXXXXX"
shop.save()
# But this is not enough
content = template.render(Context({"request" : request}))
self.failIf(content.find("pageTracker") != -1)
# It has to be activated first
shop.ga_ecommerce_tracking = True
shop.save()
# But this is still not enough
content = template.render(Context({"request" : request}))
self.failIf(content.find("pageTracker") != -1)
# There has to be an order within the session
session["order"] = Order()
# Now it works and "pageTracker" is found
content = template.render(Context({"request" : request}))
self.failIf(content.find("pageTracker") == -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 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
# Check we are using german locale
shop = lfs_get_object_or_404(Shop, pk=1)
self.assertEqual(shop.default_locale, '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):
"""
"""
self.request = RequestFactory().get("/")
self.request.session = SessionStore()
self.request.user = AnonymousUser()
# Create a tax
self.t1 = Tax.objects.create(rate=19.0)
# A product with properties and variants
self.p1 = Product.objects.create(
name=u"Product 1",
slug=u"product-1",
sku=u"SKU P1",
description=u"Description",
short_description=u"Short description product 1",
meta_description=u"Meta description product 1",
meta_keywords=u"Meta keywords product 1",
sub_type=PRODUCT_WITH_VARIANTS,
tax=self.t1,
price=1.0,
for_sale_price=0.5,
stock_amount=2,
width=1.0,
height=2.0,
length=3.0,
weight=4.0,
active=True)
# Products without properties and variants
self.p2 = Product.objects.create(name=u"Product 2",
slug=u"product-2",
active=True)
# Add a variant with color = red, size = m
self.v1 = Product.objects.create(
name=u"Variant 1",
slug=u"variant-1",
sku=u"SKU V1",
description=u"This is the description of variant 1",
meta_description=u"Meta description of variant 1",
meta_keywords=u"Meta keywords variant 1",
sub_type=VARIANT,
price=2.0,
for_sale_price=1.5,
parent=self.p1,
width=11.0,
height=12.0,
length=13.0,
weight=14.0,
active=True,
)
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
result = 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_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_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
# Added product_1 to cart
add_to_cart(request)
response = added_to_cart_items(request)
# Check we are using german locale
shop = lfs_get_object_or_404(Shop, pk=1)
self.assertEqual(shop.default_locale, 'en_US.UTF-8')
# 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 setUp(self):
"""
"""
self.request = RequestFactory().get("/")
self.request.session = SessionStore()
self.request.user = User(id=1)
self.tax = Tax.objects.create(rate=19.0)
self.p1 = Product.objects.create(name="Product 1", slug="product-1", price=10.0, tax=self.tax)
self.p2 = Product.objects.create(name="Product 2", slug="product-2", price=100.0, tax=self.tax)
self.cart = Cart.objects.create()
CartItem.objects.create(cart=self.cart, product=self.p1, amount=1)
CartItem.objects.create(cart=self.cart, product=self.p2, amount=1)
def test_standard_product(self):
session = SessionStore()
rf = RequestFactory()
request = rf.post("/", {"product_id": self.p0.id, "quantity": 1})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
# 1l login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(cart, None)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
# logout
session = SessionStore()
request = rf.post("/", {"product_id": self.p0.id, "quantity": 2})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
# 2. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].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)
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 test_configurable_product(self):
rf = RequestFactory()
session = SessionStore()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 1, "property-%s" % self.pp1.id: "A"})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
request = rf.post("/", {"product_id": self.p1.id, "quantity": 10, "property-%s" % self.pp1.id: "B"})
request.session = session
request.user = AnonymousUser()
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
# 1. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(cart, None)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
# logout
session = SessionStore()
request = rf.post("/", {"product_id": self.p1.id, "quantity": 2, "property-%s" % self.pp1.id: "A"})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
request = rf.post("/", {"product_id": self.p1.id, "quantity": 20, "property-%s" % self.pp1.id: "B"})
request.session = session
request.user = AnonymousUser()
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
self.assertEqual(int(cart.get_items()[1].amount), 20)
# 2. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 3)
self.assertEqual(int(cart.get_items()[1].amount), 30)
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,
)
def setUp(self):
"""
"""
session = SessionStore()
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 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 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 test_configurable_product(self):
rf = RequestFactory()
session = SessionStore()
request = rf.post(
"/", {
"product_id": self.p1.id,
"quantity": 1,
"property-%s" % self.pp1.id: "A"
})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
request = rf.post(
"/", {
"product_id": self.p1.id,
"quantity": 10,
"property-%s" % self.pp1.id: "B"
})
request.session = session
request.user = AnonymousUser()
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
# 1. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(cart, None)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
# logout
session = SessionStore()
request = rf.post(
"/", {
"product_id": self.p1.id,
"quantity": 2,
"property-%s" % self.pp1.id: "A"
})
request.session = session
request.user = AnonymousUser()
cart = get_cart(request)
self.assertEqual(cart, None)
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
request = rf.post(
"/", {
"product_id": self.p1.id,
"quantity": 20,
"property-%s" % self.pp1.id: "B"
})
request.session = session
request.user = AnonymousUser()
add_to_cart(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 2)
self.assertEqual(int(cart.get_items()[1].amount), 20)
# 2. login admin
request = rf.get("/")
request.session = session
request.user = self.admin
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 1)
self.assertEqual(int(cart.get_items()[1].amount), 10)
update_cart_after_login(request)
cart = get_cart(request)
self.assertEqual(int(cart.get_items()[0].amount), 3)
self.assertEqual(int(cart.get_items()[1].amount), 30)
