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_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_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_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_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)
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_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_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_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_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_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_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 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
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
# 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 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_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 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)
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 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_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_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)
# 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')
# Increase items to two
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 to amount of two is possible
result = json.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,
"shipping_method": sm.pk,
"payment_method": pm.pk
})
request.session = self.session
request.user = self.user
result = json.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 = json.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 = json.loads(refresh_cart(request).content)
self.assertEqual(result.get("message"), "")
self.assertEqual(cart.get_amount_of_items(), 3.0)