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):
self.factory = test.RequestFactory()
from django.contrib.sessions.backends.file import SessionStore
store = SessionStore()
store.save()
self.session = store
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 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_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_has_rated(self):
"""
"""
self.factory = RequestFactory()
request = self.factory.get('/')
request.user = AnonymousUser()
request.session = SessionStore()
request.session.create()
# Create some dummy pages
self.page_1 = FlatPage.objects.create(url="/test-1/", title="Test 1")
self.page_2 = FlatPage.objects.create(url="/test-2/", title="Test 2")
# At first nobody has rated
self.assertEqual(reviews.utils.has_rated(request, self.page_1), False)
self.assertEqual(reviews.utils.has_rated(request, self.page_2), False)
# Rate for page 1
Review.objects.create(content=self.page_1,
score=6.0,
active=True,
session_id=request.session.session_key)
self.assertEqual(reviews.utils.has_rated(request, self.page_1), True)
self.assertEqual(reviews.utils.has_rated(request, self.page_2), False)
# Rate for page 2
Review.objects.create(content=self.page_2,
score=6.0,
active=True,
session_id=request.session.session_key)
self.assertEqual(reviews.utils.has_rated(request, self.page_1), True)
self.assertEqual(reviews.utils.has_rated(request, self.page_2), True)
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 factory(name, **content):
channel_layer = ChannelLayer()
message = Message(content, name, channel_layer)
settings.SESSION_FILE_PATH = str(tmpdir)
message.channel_session = SessionStore()
return message
def create_request():
"""
"""
rf = RequestFactory()
request = rf.get('/')
request.session = SessionStore()
return request
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 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 init_request():
request = HttpRequest()
request.method = 'GET'
request.session = SessionStore()
request.session.create()
request._messages = BaseStorage(request)
request.user = AnonymousUser()
return request
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_request_has_processing_done_attribute(self):
"""
Test that the request has a 'csrf processing done' attribute.
"""
request = self.factory.get('/')
csrf_mw = CsrfViewMiddleware()
request.session = SessionStore(session_key='abc')
result = csrf_mw.process_view(request, our_text_plain_view, [], {})
self.assertEqual(request.csrf_processing_done, True)
self.assertEqual(result, None)
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_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 create_request(user=None):
"""
"""
rf = RequestFactory()
request = rf.get('/')
request.session = SessionStore()
if user:
request.user = user
else:
request.user = User(first_name="John Doe", email="*****@*****.**")
return request
def create_request():
"""
"""
rf = RequestFactory()
request = rf.get('/')
request.session = SessionStore()
user = User()
user.is_superuser = True
user.save()
request.user = user
return request
def create_request():
"""
"""
rf = RequestFactory()
request = rf.get('/')
request.session = SessionStore()
actor = Actor()
#actor.is_supeactor = True
actor.save()
request.actor = actor
return request
def test_copy(self):
"""
Tests the history after an object has been copied.
"""
request = RequestFactory().get("/", {"transition": 1})
request.user = self.user
request.session = SessionStore()
do_transition(request, self.p1.id)
self.assertEqual(History.objects.count(), 1)
lfc_copy(request, self.p1.id)
self.assertEqual(History.objects.count(), 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 setUp(self):
management.call_command('avocado', 'init', 'tests', quiet=True)
f1 = DataField.objects.get(pk=1)
f2 = DataField.objects.get(pk=2)
c1 = DataConcept()
c1.save()
DataConceptField(concept=c1, field=f1).save()
DataConceptField(concept=c1, field=f2).save()
self.request = HttpRequest()
self.request.session = SessionStore()
self.request.session.save()
def create_request(path="/", params=None):
"""
"""
if params is None:
params = {}
rf = RequestFactory()
request = rf.get(path, params)
request.session = SessionStore()
user = User()
user.is_superuser = True
user.save()
request.user = user
return request
def setUp(self):
management.call_command('avocado', 'init', 'tests', quiet=True)
f1 = DataField.objects.get_by_natural_key('tests', 'employee',
'first_name')
f2 = DataField.objects.get_by_natural_key('tests', 'employee',
'last_name')
self.c = DataConcept()
self.c.save()
DataConceptField(concept=self.c, field=f1).save()
DataConceptField(concept=self.c, field=f2).save()
self.request = HttpRequest()
self.request.session = SessionStore()
self.request.session.save()
def test_change_workflow_state(self):
"""
For each change a history object should be created.
"""
request = RequestFactory().get("/", {"transition": 1})
request.user = self.user
request.session = SessionStore()
do_transition(request, self.p1.id)
self.assertEqual(History.objects.count(), 1)
do_transition(request, self.p1.id)
self.assertEqual(History.objects.count(), 2)
# Delete content object
self.p1.delete()
self.assertEqual(History.objects.count(), 0)
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')
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 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 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):
"""
"""
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,
)
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)
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):
self.factory = test.RequestFactory()
store = SessionStore()
store.save()
self.session = store
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):
"""
"""
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):
"""
"""
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):
"""
"""
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,
)
