def test_basic_order_flow(with_company):
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=with_company)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
def _complete_checkout(client, expected_order_count):
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = client.soup(addresses_path)
inputs = _fill_address_inputs(addresses_soup, with_company=False)
response = client.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
# Make sure the address is initialized from storage
# Go back to addresses right before back to methods
client.soup(addresses_path)
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = client.soup(methods_path)
assert client.post(methods_path, data=extract_form_fields(
methods_soup)).status_code == 302 # Should redirect forth
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = client.soup(confirm_path)
data = extract_form_fields(confirm_soup)
assert client.post(confirm_path,
data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post == expected_order_count, "order was created"
return Order.objects.order_by("-id").first()
def test_basic_order_flow_registered(regular_user):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
get_test_script("test script", "order_received")
# paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
template_data = STEP_DATA[0]["actions"][0]["template_data"]
LANG_CODE = {"en": "US", "fi": "FI"}
for lang in ["en", "fi"]:
n_outbox_pre = len(mail.outbox)
contact = get_person_contact(regular_user)
contact.language = lang
contact.save()
c = SmartClient()
c.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD)
product_ids = _populate_client_basket(c)
addresses_soup = c.soup(addresses_path)
address = get_address(country=LANG_CODE[lang])
inputs = fill_address_inputs(addresses_soup, address)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(
methods_soup)).status_code == 302 # Should redirect forth
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert (
c.post(confirm_path,
data=extract_form_fields(confirm_soup)).status_code == 200
) # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data["accept_terms"] = True
data["product_ids"] = ",".join(product_ids[1:])
assert c.post(confirm_path,
data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
assert len(mail.outbox) == n_outbox_pre + 1, "Sending email failed"
latest_mail = mail.outbox[-1]
# mail is always sent in fallback language since user is not registered
assert latest_mail.subject == template_data[lang][
"subject"], "Subject doesn't match"
assert latest_mail.body == template_data[lang][
"body"], "Body doesn't match"
def test_basic_order_flow_registered(regular_user):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
get_test_script("test script", "order_received")
# paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
template_data = STEP_DATA[0]["actions"][0]["template_data"]
LANG_CODE = {
"en": "US",
"fi": "FI"
}
for lang in ["en", "fi"]:
n_outbox_pre = len(mail.outbox)
contact = get_person_contact(regular_user)
contact.language = lang
contact.save()
c = SmartClient()
c.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD)
product_ids = _populate_client_basket(c)
addresses_soup = c.soup(addresses_path)
address = get_address(country=LANG_CODE[lang])
inputs = fill_address_inputs(addresses_soup, address)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
assert (len(mail.outbox) == n_outbox_pre + 1), "Sending email failed"
latest_mail = mail.outbox[-1]
# mail is always sent in fallback language since user is not registered
assert latest_mail.subject == template_data[lang]["subject"], "Subject doesn't match"
assert latest_mail.body == template_data[lang]["body"], "Body doesn't match"
def test_task_type_admin(admin_user):
activate("en")
shop = factories.get_default_shop()
admin_user.set_password(ADMIN_PWD)
admin_user.save()
admin_contact = get_person_contact(admin_user)
admin_contact.shops.add(shop)
client = SmartClient()
client.login(username=admin_user.username, password=ADMIN_PWD)
# Create new task type
new_task_type_url = reverse("shuup_admin:task_type.new")
assert TaskType.objects.count() == 0
# get the form fields
soup = client.soup(new_task_type_url)
payload = extract_form_fields(soup)
payload.update({
"name__en": "My Task Type"
})
response = client.post(new_task_type_url, payload)
assert response.status_code == 302
assert TaskType.objects.count() == 1
task_type = TaskType.objects.first()
# List task types
list_task_type_url = reverse("shuup_admin:task_type.list")
list_data = {
"jq": json.dumps({
"sort": None,
"perPage": 20,
"page": 1,
"filters": {}
})
}
response = client.get(list_task_type_url, data=list_data)
assert task_type.name in response.content.decode("utf-8")
# Edit task type
edit_task_type_url = reverse("shuup_admin:task_type.edit", kwargs=dict(pk=task_type.pk))
soup = client.soup(edit_task_type_url)
payload = extract_form_fields(soup)
payload.update({
"name__en": "My Task Type Edited"
})
response = client.post(edit_task_type_url, payload)
assert response.status_code == 302
def _fill_address_inputs(soup, with_company=False):
inputs = {}
test_address = factories.get_address()
for key, value in extract_form_fields(soup.find('form',
id='addresses')).items():
if not value:
if key in ("order-tax_number", "order-company_name"):
continue
if key.startswith("shipping-") or key.startswith("billing-"):
bit = key.split("-")[1]
value = getattr(test_address, bit, None)
if not value and "email" in key:
value = "*****@*****.**" % random.random()
if not value:
value = "test"
inputs[key] = value
if with_company:
inputs["company-tax_number"] = "FI1234567-1"
inputs["company-company_name"] = "Example Oy"
else:
inputs = dict((k, v) for (k, v) in inputs.items()
if not k.startswith("company-"))
return inputs
def test_admin_edit(rf, admin_user):
shop = get_default_shop()
group = get_default_customer_group(shop)
cgpd = ContactGroupPriceDisplay.objects.for_group_and_shop(group, shop)
view = ContactGroupPriceDisplayEditView.as_view()
options = get_price_display_options_for_group_and_shop(group, shop)
assert options.show_prices
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=cgpd.pk)
response.render()
content = force_text(response.content)
data = extract_form_fields(BeautifulSoup(content))
data.update({
"price_display_mode": [PriceDisplayChoices.HIDE.value],
"group": group.id,
})
request = apply_request_middleware(rf.post("/", data), user=admin_user, shop=shop)
response = view(request, pk=cgpd.pk)
assert response.status_code == 302 # save successful
group = get_default_customer_group(shop)
options = get_price_display_options_for_group_and_shop(group, shop)
assert options.show_prices is False
assert options.include_taxes is None
# none, with_taxes, without_taxes, hide
k = "price_display_mode"
data.update({k: [PriceDisplayChoices.NONE.value]})
request = apply_request_middleware(rf.post("/", data), user=admin_user, shop=shop)
response = view(request, pk=cgpd.pk)
assert response.status_code == 302 # save successful
options = get_price_display_options_for_group_and_shop(group, shop)
assert options.show_prices is True # default
assert options.include_taxes is None
data.update({k: [PriceDisplayChoices.WITH_TAXES.value]})
request = apply_request_middleware(rf.post("/", data), user=admin_user, shop=shop)
response = view(request, pk=cgpd.pk)
assert response.status_code == 302 # save successful
options = get_price_display_options_for_group_and_shop(group, shop)
assert options.show_prices is True # default
assert options.include_taxes is True
data.update({k: [PriceDisplayChoices.WITHOUT_TAXES.value]})
request = apply_request_middleware(rf.post("/", data), user=admin_user, shop=shop)
response = view(request, pk=cgpd.pk)
assert response.status_code == 302 # save successful
options = get_price_display_options_for_group_and_shop(group, shop)
assert options.show_prices is True
assert options.include_taxes is False
def test_user_detail_contact_seed(rf):
get_default_shop()
contact = create_random_person()
# Using random data for name and email would need escaping when
# checking if it is rendered, therefore use something very basic instead
contact.name = "Matti Perustyyppi"
contact.email = "*****@*****.**"
contact.save()
view_func = UserDetailView.as_view()
# Check that fields populate . . .
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}))
response = view_func(request)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
# POST the password too to create the user . . .
post = extract_form_fields(BeautifulSoup(content))
post["password"] = "******"
request.method = "POST"
request.POST = post
response = view_func(request)
assert response.status_code < 500
# Check this new user is visible in the details now
user = Contact.objects.get(pk=contact.pk).user
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}))
response = view_func(request, pk=user.pk)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
def test_iframe_mode(rf, admin_user, extra_query_param, extra_query_value,
expected_script):
get_default_shop()
view = load(
"shuup.admin.modules.categories.views:CategoryEditView").as_view()
request = apply_request_middleware(rf.get("/", {"mode": "iframe"}),
user=admin_user)
response = view(request)
if hasattr(response, "render"):
response.render()
assert 200 <= response.status_code < 300
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content, "lxml"))
post.update({"base-name__en": "Name"})
post.pop("base-image")
# save iframe mode
request = apply_request_middleware(rf.post("/", post), user=admin_user)
request.GET = request.GET.copy()
request.GET["mode"] = "iframe"
if extra_query_param:
request.GET[extra_query_param] = extra_query_value
response = view(request)
assert response.status_code == 302
client = Client()
client.login(username="******", password="******")
response = client.get(response.url)
assert response.status_code == 200
assert expected_script in force_text(response.content)
def test_iframe_mode(rf, admin_user, extra_query_param, extra_query_value, expected_script):
get_default_shop()
view = load("shuup.admin.modules.categories.views:CategoryEditView").as_view()
request = apply_request_middleware(rf.get("/", {"mode": "iframe"}), user=admin_user)
response = view(request)
if hasattr(response, "render"):
response.render()
assert 200 <= response.status_code < 300
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content, "lxml"))
post.update({
"base-name__en": "Name"
})
post.pop("base-image")
# save iframe mode
request = apply_request_middleware(rf.post("/", post), user=admin_user)
request.GET = request.GET.copy()
request.GET["mode"] = "iframe"
if extra_query_param:
request.GET[extra_query_param] = extra_query_value
response = view(request)
assert response.status_code == 302
client = Client()
client.login(username="******", password="******")
response = client.get(response.url)
assert response.status_code == 200
assert expected_script in force_text(response.content)
def test_user_detail_contact_seed(rf, admin_user):
get_default_shop()
contact = create_random_person()
# Using random data for name and email would need escaping when
# checking if it is rendered, therefore use something very basic instead
contact.name = "Matti Perustyyppi"
contact.email = "*****@*****.**"
contact.save()
view_func = UserDetailView.as_view()
# Check that fields populate . . .
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}), user=admin_user)
response = view_func(request)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
# POST the password too to create the user . . .
post = extract_form_fields(BeautifulSoup(content))
post["password"] = "******"
request.method = "POST"
request.POST = post
response = view_func(request)
assert response.status_code < 500
# Check this new user is visible in the details now
user = Contact.objects.get(pk=contact.pk).user
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}), user=admin_user)
response = view_func(request, pk=user.pk)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
def _populate_client_basket(client):
product_ids = []
index = client.soup("/")
product_links = index.find_all("a", rel="product-detail")
assert product_links
for i in range(3): # add three different products
product_detail_path = product_links[i]["href"]
assert product_detail_path
product_detail_soup = client.soup(product_detail_path)
inputs = extract_form_fields(product_detail_soup)
basket_path = reverse("shuup:basket")
add_to_basket_resp = client.post(basket_path,
data={
"command": "add",
"product_id":
inputs["product_id"],
"quantity": 1,
"supplier":
get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
product_ids.append(inputs["product_id"])
basket_soup = client.soup(basket_path)
assert b'no such element' not in basket_soup.renderContents(
), 'All product details are not rendered correctly'
return product_ids
def test_edit_view_adding_messages_to_form_group(rf, admin_user):
get_default_shop() # obvious prerequisite
product = get_default_product()
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=product.pk)
response.render()
assert 200 <= response.status_code < 300
assert ProductEditView.add_form_errors_as_messages
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content))
post_data = {
# Error in the base form part
"base-name__en": "",
}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=product.pk)
errors = response.context_data["form"].errors
assert "base" in errors
assert "name__en" in errors["base"]
def test_edit_view_adding_messages_to_form_group(rf, admin_user):
shop = get_default_shop() # obvious prerequisite
product = get_default_product()
shop_product = product.get_shop_instance(shop)
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=shop_product.pk)
response.render()
assert 200 <= response.status_code < 300
assert ProductEditView.add_form_errors_as_messages
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content, "lxml"))
post_data = {
# Error in the base form part
"base-name__en": "",
}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=shop_product.pk)
errors = response.context_data["form"].errors
assert "base" in errors
assert "name__en" in errors["base"]
def test_basic_order_flow(with_company, with_signal):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=with_company)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
# Make sure the address is initialized from storage
# Go back to addresses right before back to methods
c.soup(addresses_path)
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(
methods_soup)).status_code == 302 # Should redirect forth
if with_signal:
checkout_complete.connect(checkout_complete_signal,
dispatch_uid="checkout_complete_signal")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(
confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['accept_terms'] = True
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path,
data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
order = Order.objects.first()
expected_ip = "127.0.0.2" if with_signal else "127.0.0.1"
assert order.ip_address == expected_ip
if with_signal:
checkout_complete.disconnect(dispatch_uid="checkout_complete_signal")
def test_create_api_permission_groups(rf, admin_user):
shop = factories.get_default_shop()
group1 = Group.objects.create(name="group1")
group2 = Group.objects.create(name="group2")
client = SmartClient()
client.force_login(admin_user)
url = reverse("shuup_admin:api_permission_groups.new")
response, soup = client.response_and_soup(url)
assert response.status_code == 200
inputs = extract_form_fields(soup)
name = printable_gibberish()
inputs["base-name"] = name
inputs["base-groups"] = [group2.pk]
assert APIPermissionGroups.objects.count() == 0
response = client.post(url, data=inputs)
assert response.status_code == 302
permission_groups = APIPermissionGroups.objects.first()
assert permission_groups.name == name
assert permission_groups.groups.count() == 1
assert group2 in permission_groups.groups.all()
edit_url = reverse("shuup_admin:api_permission_groups.edit",
kwargs={"pk": permission_groups.pk})
assert response.url == edit_url
response, soup = client.response_and_soup(edit_url)
assert response.status_code == 200
inputs = extract_form_fields(soup)
new_name = printable_gibberish()
inputs["base-name"] = new_name
inputs["base-groups"] = [group2.pk, group1.pk]
response = client.post(edit_url, data=inputs)
assert response.status_code == 302
assert response.url == edit_url
permission_groups.refresh_from_db()
assert permission_groups.name == new_name
assert permission_groups.groups.count() == 2
assert group1 in permission_groups.groups.all()
assert group2 in permission_groups.groups.all()
def test_reviews_view(rf):
shop = factories.get_default_shop()
customer = factories.create_random_person("en")
user = factories.create_random_user("en")
user.set_password("user")
user.save()
customer.user = user
customer.save()
client = SmartClient()
client.login(username=user.username, password="******")
# no reviews in dashboard
response = client.get(reverse("shuup:dashboard"))
assert response.status_code == 200
response.render()
content = response.content.decode("utf-8")
assert "You haven't made any reviews yet" in content
# create some reviews for customer
[create_random_review_for_reviwer(shop, customer) for _ in range(15)]
# create some orders to review
[create_random_order_to_review(shop, customer) for order in range(3)]
# reload dashboard
response = client.get(reverse("shuup:dashboard"))
assert response.status_code == 200
response.render()
content = response.content.decode("utf-8")
assert "Last reviews" in content
# show all reviews
response, soup = client.response_and_soup(reverse("shuup:product_reviews"))
assert response.status_code == 200
response.render()
content = response.content.decode("utf-8")
assert "Products to Review" in content
form_data = extract_form_fields(soup)
for key in form_data.keys():
if key.endswith("comment"):
form_data[key] = Faker().text(100)
if key.endswith("rating"):
form_data[key] = random.randint(1, 5)
if key.endswith("would_recommend"):
form_data[key] = random.choice([True, False])
# post reviews
request = rf.post("/")
request.person = request.customer = customer
request.shop = shop
response = client.post(reverse("shuup:product_reviews"), data=form_data)
assert response.status_code == 200
response.render()
content = response.content.decode("utf-8")
assert "Products to Review" not in content
def test_basic_order_flow(with_company, with_signal):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=with_company)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
# Make sure the address is initialized from storage
# Go back to addresses right before back to methods
c.soup(addresses_path)
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
if with_signal:
checkout_complete.connect(checkout_complete_signal, dispatch_uid="checkout_complete_signal")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
order = Order.objects.first()
expected_ip = "127.0.0.2" if with_signal else "127.0.0.1"
assert order.ip_address == expected_ip
if with_signal:
checkout_complete.disconnect(dispatch_uid="checkout_complete_signal")
def test_create_api_access(rf, admin_user):
shop = factories.get_default_shop()
client = SmartClient()
client.force_login(admin_user)
url = reverse("shuup_admin:api_access.new")
response, soup = client.response_and_soup(url)
assert response.status_code == 200
inputs = extract_form_fields(soup)
name = printable_gibberish()
inputs["base-name"] = name
inputs["base-enabled"] = False
assert APIAccess.objects.count() == 0
response = client.post(url, data=inputs)
assert response.status_code == 302
api_access = APIAccess.objects.first()
assert api_access.enabled is False
assert api_access.name == name
edit_url = reverse("shuup_admin:api_access.edit",
kwargs={"pk": api_access.pk})
assert response.url == edit_url
response, soup = client.response_and_soup(edit_url)
assert response.status_code == 200
inputs = extract_form_fields(soup)
new_name = printable_gibberish()
inputs["base-name"] = new_name
inputs["base-enabled"] = True
response = client.post(edit_url, data=inputs)
assert response.status_code == 302
assert response.url == edit_url
api_access.refresh_from_db()
assert api_access.enabled
assert api_access.name == new_name
def test_gdpr_admin_settings(client, admin_user):
"""
Test that admin user can enable GDPR and add cookie categories
"""
activate("en")
shop = factories.get_default_shop()
client = SmartClient()
admin_user.set_password("admin")
admin_user.save()
client.login(username=admin_user.username, password="******")
admin_settings_url = reverse("shuup_admin:gdpr.settings")
assert not GDPRSettings.objects.exists()
response = client.soup(admin_settings_url)
assert GDPRSettings.objects.exists()
s = GDPRSettings.objects.first()
assert s.cookie_banner_content == settings.SHUUP_GDPR_DEFAULT_BANNER_STRING
assert s.cookie_privacy_excerpt == settings.SHUUP_GDPR_DEFAULT_EXCERPT_STRING
assert GDPRCookieCategory.objects.count() == 0
page = Page.objects.create(shop=shop, available_from=now())
page.title = "test"
page.save()
# create the settings with only basic options
payload = extract_form_fields(response)
payload.pop("base-consent_pages")
payload.update({
"base-enabled": True,
"base-privacy_policy_page": page.pk,
"base-cookie_banner_content__en": "Banner content",
"base-cookie_privacy_excerpt__en": "Cookie excerpt",
"cookie_categories-0-id": "",
"cookie_categories-0-always_active": 1,
"cookie_categories-0-name__en": "required",
"cookie_categories-0-how_is_used__en": "to work",
"cookie_categories-0-cookies": "sessionid",
})
response = client.post(admin_settings_url, data=payload)
assert response.status_code == 302
assert GDPRCookieCategory.objects.count() == 1
# add one more cookie category
payload.update({
"cookie_categories-1-id": "",
"cookie_categories-1-always_active": 1,
"cookie_categories-1-name__en": "Maybe",
"cookie_categories-1-how_is_used__en": "to spy",
"cookie_categories-1-cookies": "_ga",
})
client.post(admin_settings_url, data=payload)
assert GDPRCookieCategory.objects.count() == 2
def test_gdpr_admin_settings(client, admin_user):
"""
Test that admin user can enable GDPR and add cookie categories
"""
activate("en")
shop = factories.get_default_shop()
client = SmartClient()
admin_user.set_password("admin")
admin_user.save()
client.login(username=admin_user.username, password="******")
admin_settings_url = reverse("shuup_admin:gdpr.settings")
assert not GDPRSettings.objects.exists()
response = client.soup(admin_settings_url)
assert GDPRSettings.objects.exists()
s = GDPRSettings.objects.first()
assert s.cookie_banner_content == settings.SHUUP_GDPR_DEFAULT_BANNER_STRING
assert s.cookie_privacy_excerpt == settings.SHUUP_GDPR_DEFAULT_EXCERPT_STRING
assert GDPRCookieCategory.objects.count() == 0
page = Page.objects.create(shop=shop, available_from=now())
page.title = "test"
page.save()
# create the settings with only basic options
payload = extract_form_fields(response)
payload.update({
"base-enabled": True,
"base-privacy_policy_page": page.pk,
"base-cookie_banner_content__en": "Banner content",
"base-cookie_privacy_excerpt__en": "Cookie excerpt",
"cookie_categories-0-id": "",
"cookie_categories-0-always_active": 1,
"cookie_categories-0-name__en": "required",
"cookie_categories-0-how_is_used__en": "to work",
"cookie_categories-0-cookies": "sessionid"
})
response = client.post(admin_settings_url, data=payload)
assert response.status_code == 302
assert GDPRCookieCategory.objects.count() == 1
# add one more cookie category
payload.update({
"cookie_categories-1-id": "",
"cookie_categories-1-always_active": 1,
"cookie_categories-1-name__en": "Maybe",
"cookie_categories-1-how_is_used__en": "to spy",
"cookie_categories-1-cookies": "_ga"
})
client.post(admin_settings_url, data=payload)
assert GDPRCookieCategory.objects.count() == 2
def _complete_checkout(client, expected_order_count):
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = client.soup(addresses_path)
inputs = _fill_address_inputs(addresses_soup, with_company=False)
response = client.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
# Make sure the address is initialized from storage
# Go back to addresses right before back to methods
client.soup(addresses_path)
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = client.soup(methods_path)
assert client.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = client.soup(confirm_path)
data = extract_form_fields(confirm_soup)
assert client.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post == expected_order_count, "order was created"
return Order.objects.order_by("-id").first()
def test_admin_form_part(admin_user):
factories.get_default_shop()
client = SmartClient()
client.login(username=admin_user.username, password="******")
assert Page.objects.count() == 0
response, soup = client.response_and_soup(
reverse("shuup_admin:simple_cms.page.new"))
assert response.status_code == 200
payload = extract_form_fields(soup)
# do some cleaning
for key in payload.keys():
if payload[key] is None:
payload[key] = ""
# create 9 articles
for i in range(9):
payload.update({
"base-title__en": "My Article %d" % i,
"base-url__en": "my-article-%d" % i,
"base-available_from": "0%s/01/2018 00:00:00" % (i + 1),
"base-available_to": "0%s/01/2019 00:00:00" % (i + 1),
"base-content__en": "Some content here %d" % i,
"base-template_name": "shuup_cms_blog/blog_page.jinja",
"blog-is_blog_article": True,
"blog-image": factories.get_random_filer_image().pk,
"blog-small_description__en": "small description %d" % i
})
response = client.post(reverse("shuup_admin:simple_cms.page.new"),
data=payload)
assert response.status_code == 302
assert Page.objects.count() == (i + 1)
response, soup = client.response_and_soup(
reverse("shuup:cms_page",
kwargs=dict(url=payload["base-url__en"])))
assert response.status_code == 200
assert soup.find("div", {"class": "article-features"})
# update blog image of the last page
payload.update({
"blog-image": factories.get_random_filer_image().pk,
})
response = client.post(reverse("shuup_admin:simple_cms.page.edit",
kwargs=dict(pk=Page.objects.last().pk)),
data=payload)
assert response.status_code == 302
def test_gdpr_admin_settings(client, admin_user):
"""
Test that admin user can enable GDPR and add cookie categories
"""
activate("en")
shop = factories.get_default_shop()
client = SmartClient()
admin_user.set_password("admin")
admin_user.save()
client.login(username=admin_user.username, password="******")
admin_settings_url = reverse("shuup_admin:gdpr.settings")
assert not GDPRSettings.objects.exists()
response = client.soup(admin_settings_url)
assert GDPRSettings.objects.exists()
assert GDPRCookieCategory.objects.count() == 0
# create the settings with only basic options
payload = extract_form_fields(response)
payload.update({
"base-enabled": True,
"base-cookie_banner_content__en": "Banner content",
"base-cookie_privacy_excerpt__en": "Cookie excerpt",
"cookie_categories-0-id": "",
"cookie_categories-0-always_active": 1,
"cookie_categories-0-name__en": "required",
"cookie_categories-0-how_is_used__en": "to work",
"cookie_categories-0-cookies": "sessionid"
})
response = client.post(admin_settings_url, data=payload)
assert response.status_code == 302
assert GDPRCookieCategory.objects.count() == 1
assert Page.objects.visible(shop).filter(
page_type=PageType.GDPR_CONSENT_DOCUMENT).exists()
# add one more cookie category
payload.update({
"cookie_categories-1-id": "",
"cookie_categories-1-always_active": 1,
"cookie_categories-1-name__en": "Maybe",
"cookie_categories-1-how_is_used__en": "to spy",
"cookie_categories-1-cookies": "_ga"
})
client.post(admin_settings_url, data=payload)
assert GDPRCookieCategory.objects.count() == 2
def _populate_client_basket(client):
index = client.soup("/")
product_links = index.find_all("a", rel="product-detail")
assert product_links
product_detail_path = product_links[0]["href"]
assert product_detail_path
product_detail_soup = client.soup(product_detail_path)
inputs = extract_form_fields(product_detail_soup)
basket_path = reverse("shuup:basket")
for i in range(3): # Add the same product thrice
add_to_basket_resp = client.post(basket_path, data={
"command": "add",
"product_id": inputs["product_id"],
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
basket_soup = client.soup(basket_path)
assert b'no such element' not in basket_soup.renderContents(), 'All product details are not rendered correctly'
def test_new_user_information_edit():
client = SmartClient()
get_default_shop()
# create new user
user_password = "******"
user = get_user_model().objects.create_user(
username="******",
email="*****@*****.**",
password=user_password,
first_name="Niilo",
last_name="Nyyppä",
)
client.login(username=user.username, password=user_password)
# make sure all information matches in form
customer_edit_url = reverse("shuup:customer_edit")
soup = client.soup(customer_edit_url)
assert soup.find(attrs={"name": "contact-email"})["value"] == user.email
assert soup.find(
attrs={"name": "contact-first_name"})["value"] == user.first_name
assert soup.find(
attrs={"name": "contact-last_name"})["value"] == user.last_name
# Test POSTing
form = extract_form_fields(soup)
new_email = "*****@*****.**"
form["contact-email"] = new_email
form["contact-country"] = "FI"
for prefix in ("billing", "shipping"):
form["%s-city" % prefix] = "test-city"
form["%s-email" % prefix] = new_email
form["%s-street" % prefix] = "test-street"
form["%s-country" % prefix] = "FI"
response, soup = client.response_and_soup(customer_edit_url, form, "post")
assert response.status_code == 302
assert get_user_model().objects.get(pk=user.pk).email == new_email
def fill_address_inputs(soup, address, with_company=False):
inputs = {}
for key, value in extract_form_fields(soup.find('form', id='addresses')).items():
if not value:
if key in ("order-tax_number", "order-company_name"):
continue
if key.startswith("shipping-") or key.startswith("billing-"):
bit = key.split("-")[1]
value = getattr(address, bit, None)
if not value and "email" in key:
value = "*****@*****.**" % random.random()
if not value:
value = "test"
inputs[key] = value
if with_company:
inputs["company-tax_number"] = "FI1234567-1"
inputs["company-company_name"] = "Example Oy"
else:
inputs = dict((k, v) for (k, v) in inputs.items() if not k.startswith("company-"))
return inputs
def test_new_user_information_edit():
client = SmartClient()
get_default_shop()
# create new user
user_password = "******"
user = get_user_model().objects.create_user(
username="******",
email="*****@*****.**",
password=user_password,
first_name="Niilo",
last_name="Nyyppä",
)
client.login(username=user.username, password=user_password)
# make sure all information matches in form
customer_edit_url = reverse("shuup:customer_edit")
soup = client.soup(customer_edit_url)
assert soup.find(attrs={"name": "contact-email"})["value"] == user.email
assert soup.find(attrs={"name": "contact-first_name"})["value"] == user.first_name
assert soup.find(attrs={"name": "contact-last_name"})["value"] == user.last_name
# Test POSTing
form = extract_form_fields(soup)
new_email = "*****@*****.**"
form["contact-email"] = new_email
form["contact-country"] = "FI"
for prefix in ("billing", "shipping"):
form["%s-city" % prefix] = "test-city"
form["%s-email" % prefix] = new_email
form["%s-street" % prefix] = "test-street"
form["%s-country" % prefix] = "FI"
response, soup = client.response_and_soup(customer_edit_url, form, "post")
assert response.status_code == 302
assert get_user_model().objects.get(pk=user.pk).email == new_email
def test_checkout_with_success():
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
client = SmartClient()
# first step - register user
person_data = {
"email": "*****@*****.**",
"password1": "password",
"password2": "password",
"person_type": PersonType.FISICA.value,
"PF-name": "NOME DA PESSOA",
"PF-cpf": "012.345.678-90",
"PF-rg": "312321",
"PF-birth_date": "03/28/1954",
"PF-gender": Gender.MALE.value
}
result = client.post(reverse("shuup:registration_register"), data=person_data)
assert not result is None
user = get_user_model().objects.get(email=person_data['email'])
assert user.is_active
# second step -add something into the basket
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = client.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# third step - go to checkout and set the addresses
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_data = {
'billing-name': 'maria da silva',
'billing-street': 'rua billing',
'billing-street2': 'apto',
'billing-street3': 'bairro outrem',
'billing-postal_code': '89090-200',
'billing-city': 'plumenau',
'billing-region': 'PR',
'billing-country': 'BR',
'billing-phone': '41 2332-0213',
'billing_extra-numero': '563',
'billing_extra-cel': '13 98431-4345',
'billing_extra-ponto_ref': 'longe de tudo',
'shipping-name': 'joao da silva',
'shipping-street': 'rua shipping',
'shipping-street2': 'complemento',
'shipping-street3': 'bairro',
'shipping-postal_code': '89050120',
'shipping-city': 'indaial',
'shipping-region': 'SC',
'shipping-country': 'BR',
'shipping-phone': '39 9999-2332',
'shipping_extra-numero': '323',
'shipping_extra-cel': '21 4444-3333',
'shipping_extra-ponto_ref': 'proximo posto',
}
response = client.post(addresses_path, data=addresses_data)
print (response.content)
assert response.status_code == 302 # Should redirect forth
# Set the payment and shipping methods
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = client.soup(methods_path)
assert client.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
# Confirm the order
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = client.soup(confirm_path)
assert client.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 302 # Should redirect forth
def test_debit_auto_capture_with_auth():
"""
Caso:
- Transação com Cartão de Débito
- Auto captura HABILITADO
- Com URL para autenticação
- 1 parcela
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 10,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
ORDER_TOTAL = PRODUCT_PRICE * 10
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
assert isinstance(processor, CieloPaymentProcessor)
# aumenta o limite máximo de parcelas para 4
cielo_config = get_cielo_config()
cielo_config.max_installments = 4
cielo_config.save()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
transaction_path = reverse("shuup:cielo_make_transaction")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 302, "Confirm should first redirect forth"
assert response.url.endswith(payment_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(1,
decimal_to_int_cents(ORDER_TOTAL),
CieloProduct.InstallmentCredit,
CieloCardBrand.Visa,
CC_VISA_4X_INFO['installments'],
tid,
return_url=None)
transacao = get_approved_transaction(transacao)
transacao = get_captured_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
with patch.object(CieloRequest, 'capturar',
return_value=transacao):
# Phase: pay
response = c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_4X_INFO)
assert response.status_code == 200
json_content = json.loads(response.content.decode("utf-8"))
assert json_content['redirect_url'].endswith(
reverse("shuup:cielo_transaction_return",
kwargs={"cielo_order_pk": 1}))
cielo_transaction = CieloTransaction.objects.get(tid=tid)
assert cielo_transaction.cc_brand == CC_VISA_4X_INFO[
'cc_brand']
assert cielo_transaction.cc_holder == CC_VISA_4X_INFO[
'cc_holder']
assert cielo_transaction.installments == CC_VISA_4X_INFO[
'installments']
assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit
assert abs(cielo_transaction.total_value - ORDER_TOTAL) < 0.01
assert cielo_transaction.status.value == transacao.status
response = c.post(json_content['redirect_url'])
assert response.status_code == 302
assert response.url.endswith(confirm_path)
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path,
data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
order = Order.objects.filter(
payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment",
kwargs={
"pk": order.pk,
"key": order.key
})
process_payment_return_path = reverse(
"shuup:order_process_payment_return",
kwargs={
"pk": order.pk,
"key": order.key
})
order_complete_path = reverse("shuup:order_complete",
kwargs={
"pk": order.pk,
"key": order.key
})
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
# Check payment return
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
cielo_transaction = CieloTransaction.objects.get(
order_transaction__order=order, tid=tid)
assert cielo_transaction.status == CieloTransactionStatus.Captured
assert cielo_transaction.authorization_nsu == str(
transacao.autorizacao.nsu)
assert cielo_transaction.authorization_lr == str(
transacao.autorizacao.lr)
assert cielo_transaction.authorization_date == iso8601.parse_date(
transacao.autorizacao.data_hora)
assert cielo_transaction.authentication_eci == transacao.autenticacao.eci
assert cielo_transaction.authentication_date == iso8601.parse_date(
transacao.autenticacao.data_hora)
assert cielo_transaction.total_captured_value == ORDER_TOTAL
assert cielo_transaction.total_reversed_value == Decimal()
order.refresh_from_db()
assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY)
assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY)
assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_fail():
"""
Caso:
- Transação com Cartão de Crédito
- Auto captura desabilidato
- Sem URL para autenticação
- 4 parcelas
- dados do pagamento nao existem
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 10,
"supplier": get_default_supplier().pk
})
ORDER_TOTAL = PRODUCT_PRICE * 10
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
# aumenta o limite máximo de parcelas para 4
cielo_config = get_cielo_config()
cielo_config.max_installments = 4
cielo_config.save()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
transaction_path = reverse("shuup:cielo_make_transaction")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
c.get(confirm_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(1,
decimal_to_int_cents(ORDER_TOTAL),
CieloProduct.InstallmentCredit,
CieloCardBrand.Visa,
CC_VISA_4X_INFO['installments'],
tid,
return_url=None)
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: pay
c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_4X_INFO)
json_content = json.loads(response.content.decode("utf-8"))
response = c.post(json_content['redirect_url'])
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path,
data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment",
kwargs={
"pk": order.pk,
"key": order.key
})
# FORCE CLEAR ORDER PAYMENT DATA
order.payment_data = {}
order.save()
response = c.get(process_payment_path)
order.refresh_from_db()
assert order.status == OrderStatus.objects.get_default_canceled()
def test_credit_card_success_3():
"""
Caso:
- Transação com Cartão de Crédito
- Auto captura desabilidato
- Sem URL para autenticação
- 4 parcelas com juros
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 10,
"supplier": get_default_supplier().pk
})
ORDER_TOTAL = PRODUCT_PRICE * 10
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
# aumenta o limite máximo de parcelas para 4
cielo_config = get_cielo_config()
cielo_config.max_installments = 4
cielo_config.installments_without_interest = 1
cielo_config.interest_rate = Decimal(3.20)
cielo_config.save()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
transaction_path = reverse("shuup:cielo_make_transaction")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
c.get(confirm_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(
numero=1,
valor=decimal_to_int_cents(ORDER_TOTAL),
produto=CieloProduct.Credit,
bandeira=CieloCardBrand.Visa,
parcelas=CC_VISA_1X_INFO['installments'],
tid=tid,
return_url=None)
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: pay
c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_4X_INFO)
assert response.status_code == 200
json_content = json.loads(response.content.decode("utf-8"))
assert json_content['redirect_url'].endswith(
reverse("shuup:cielo_transaction_return",
kwargs={"cielo_order_pk": 1}))
choices = InstallmentContext(
ORDER_TOTAL, cielo_config).get_intallments_choices()
cielo_transaction = CieloTransaction.objects.get(tid=tid)
assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit
assert abs(cielo_transaction.total_value -
choices[3][2]) <= Decimal(0.01)
assert cielo_transaction.status.value == transacao.status
response = c.post(json_content['redirect_url'])
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path,
data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
assert abs(order.taxful_total_price.value -
choices[3][2]) <= Decimal(0.01)
process_payment_path = reverse("shuup:order_process_payment",
kwargs={
"pk": order.pk,
"key": order.key
})
process_payment_return_path = reverse(
"shuup:order_process_payment_return",
kwargs={
"pk": order.pk,
"key": order.key
})
response = c.get(process_payment_path)
response = c.get(process_payment_return_path)
cielo_transaction = CieloTransaction.objects.get(
order_transaction__order=order, tid=tid)
order.refresh_from_db()
assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY)
assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY)
assert order.payment_status == PaymentStatus.NOT_PAID
def test_checkout_with_success():
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
client = SmartClient()
# first step - register user
person_data = {
"email": "*****@*****.**",
"password1": "password",
"password2": "password",
"person_type": PersonType.FISICA.value,
"PF-name": "NOME DA PESSOA",
"PF-cpf": "012.345.678-90",
"PF-rg": "312321",
"PF-birth_date": "03/28/1954",
"PF-gender": Gender.MALE.value
}
result = client.post(reverse("shuup:registration_register"),
data=person_data)
assert not result is None
user = get_user_model().objects.get(email=person_data['email'])
assert user.is_active
# second step -add something into the basket
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = client.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# third step - go to checkout and set the addresses
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_data = {
'billing-name': 'maria da silva',
'billing-street': 'rua billing',
'billing-street2': 'apto',
'billing-street3': 'bairro outrem',
'billing-postal_code': '89090-200',
'billing-city': 'plumenau',
'billing-region': 'PR',
'billing-country': 'BR',
'billing-phone': '41 2332-0213',
'billing_extra-numero': '563',
'billing_extra-cel': '13 98431-4345',
'billing_extra-ponto_ref': 'longe de tudo',
'shipping-name': 'joao da silva',
'shipping-street': 'rua shipping',
'shipping-street2': 'complemento',
'shipping-street3': 'bairro',
'shipping-postal_code': '89050120',
'shipping-city': 'indaial',
'shipping-region': 'SC',
'shipping-country': 'BR',
'shipping-phone': '39 9999-2332',
'shipping_extra-numero': '323',
'shipping_extra-cel': '21 4444-3333',
'shipping_extra-ponto_ref': 'proximo posto',
}
response = client.post(addresses_path, data=addresses_data)
print(response.content)
assert response.status_code == 302 # Should redirect forth
# Set the payment and shipping methods
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = client.soup(methods_path)
assert client.post(methods_path, data=extract_form_fields(
methods_soup)).status_code == 302 # Should redirect forth
# Confirm the order
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = client.soup(confirm_path)
assert client.post(confirm_path, data=extract_form_fields(
confirm_soup)).status_code == 302 # Should redirect forth
def test_product_edit_view(rf, admin_user, settings):
shop = get_default_shop() # obvious prerequisite
product = get_default_product()
shop_product = product.get_shop_instance(shop)
cat = CategoryFactory()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=product.pk)
response.render()
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content))
# Needed for Django 1.8 tests to pass
post.update({
'shop1-default_price_value': '42',
'images-TOTAL_FORMS': '0',
'media-TOTAL_FORMS': '0',
'base-name__fi': 'test',
'base-name__it': 'test',
'base-name__ja': 'test',
'base-name__pt-br': 'test',
'base-name__zh-hans': 'test',
})
post_data = {'shop1-primary_category': [], 'shop1-categories': []}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=product.pk)
shop_product.refresh_from_db()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
'shop1-default_price_value': 12,
'shop1-primary_category': [cat.pk],
'shop1-categories': []
}
post.update(post_data)
usable_post = {}
for k, v in six.iteritems(post):
if not k:
continue
if not post[k]:
continue
usable_post[k] = v
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
else:
assert not shop_product.categories.count()
assert shop_product.primary_category == cat
post_data = {'shop1-primary_category': [], 'shop1-categories': []}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=product.pk)
# empty again
shop_product = ShopProduct.objects.first()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {'shop1-primary_category': [], 'shop1-categories': [cat.pk]}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
cat2 = CategoryFactory()
post_data = {
'shop1-primary_category': [],
'shop1-categories': [cat.pk, cat2.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 2
assert cat in shop_product.categories.all()
assert cat2 in shop_product.categories.all()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
def test_product_edit_view(rf, admin_user, settings):
shop = get_default_shop() # obvious prerequisite
shop.staff_members.add(admin_user)
parent = create_product("ComplexVarParent",
shop=shop,
supplier=get_default_supplier())
sizes = [("%sL" % ("X" * x)) for x in range(4)]
for size in sizes:
child = create_product("ComplexVarChild-%s" % size,
shop=shop,
supplier=get_default_supplier())
child.link_to_parent(parent, variables={"size": size})
shop_product = parent.get_shop_instance(shop)
cat = CategoryFactory()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=shop_product.pk)
response.render()
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content, "lxml"))
# Needed for Django 1.8 tests to pass
post.update({
"shop1-default_price_value": "42",
"images-TOTAL_FORMS": "0",
"media-TOTAL_FORMS": "0",
"base-name__fi": "test",
"base-name__it": "test",
"base-name__ja": "test",
"base-name__pt-br": "test",
"base-name__zh-hans": "test",
"base-name__es": "test",
})
post_data = {"shop1-primary_category": [], "shop1-categories": []}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product.refresh_from_db()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
"shop1-default_price_value": 12,
"shop1-primary_category": cat.pk,
"shop1-categories": []
}
post.update(post_data)
usable_post = {}
for k, v in six.iteritems(post):
if not k:
continue
if not post[k]:
continue
usable_post[k] = v
with patch("django.db.transaction.on_commit", new=atomic_commit_mock):
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.primary_category
# the catalog price was indexed
catalog_price = ProductCatalogPrice.objects.filter(
shop=shop_product.shop, product=shop_product.product).first()
assert catalog_price.price_value == shop_product.default_price_value
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
else:
assert not shop_product.categories.count()
assert shop_product.primary_category == cat
post_data = {"shop1-primary_category": [], "shop1-categories": []}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=shop_product.pk)
# empty again
shop_product = ShopProduct.objects.first()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {"shop1-primary_category": [], "shop1-categories": [cat.pk]}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
cat2 = CategoryFactory()
post_data = {
"shop1-primary_category": [],
"shop1-categories": [cat.pk, cat2.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post),
user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 2
assert cat in shop_product.categories.all()
assert cat2 in shop_product.categories.all()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
# Test for showing alert of validation issues
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=shop_product.pk)
response.render()
content = force_text(response.content)
soup = BeautifulSoup(content, "lxml")
alert = soup.find_all("div", {"class": "validation-issues-alert"})
assert not alert
with override_provides(
"admin_product_validator",
["shuup.testing.admin_product_validator:TestAdminProductValidator"],
):
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=shop_product.pk)
response.render()
content = force_text(response.content)
soup = BeautifulSoup(content, "lxml")
alert = soup.find_all(
"div", {"class": "validation-issues-alert alert alert-danger"})
assert alert
alert_danger = soup.find_all("div", {"class": "alert-danger"})
assert alert_danger
alert = soup.find_all(
"div", {"class": "validation-issues-alert alert alert-warning"})
alert_div = alert[0]
strong = alert_div.find_all("strong")
assert strong
script = alert_div.find_all("script")
assert not script
def test_order_flow_with_payment_phase_credit_card_success():
"""
Caso:
- Transação com Cartão de Crédito
- Auto captura desabilidato
- Com URL para autenticação
- 1 parcela sem juros
"""
initialize()
c = SmartClient()
default_product = get_default_product()
ORDER_TOTAL = PRODUCT_PRICE * 1
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
assert isinstance(processor, CieloPaymentProcessor)
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
transaction_path = reverse("shuup:cielo_make_transaction")
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 302, "Confirm should first redirect forth"
assert response.url.endswith(payment_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(numero=1,
valor=decimal_to_int_cents(ORDER_TOTAL),
produto=CieloProduct.Credit,
bandeira=CieloCardBrand.Visa,
parcelas=CC_VISA_1X_INFO['installments'],
tid=tid)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: Payment
response = c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_1X_INFO)
assert response.status_code == 200
json_content = json.loads(response.content.decode("utf-8"))
assert json_content['redirect_url'] == AUTH_URL
cielo_transaction = CieloTransaction.objects.get(tid=tid)
assert cielo_transaction.status == CieloTransactionStatus.InProgress
assert cielo_transaction.cc_brand == CC_VISA_1X_INFO['cc_brand']
assert cielo_transaction.cc_holder == CC_VISA_1X_INFO['cc_holder']
assert cielo_transaction.installments == CC_VISA_1X_INFO['installments']
assert cielo_transaction.cc_product == CieloProduct.Credit
assert abs(cielo_transaction.total_value - ORDER_TOTAL) < 0.01
assert cielo_transaction.status.value == transacao.status
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: Confirm Order
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == 1
order = Order.objects.filter(payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key})
# Visit payment page
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
# Check payment return
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order, tid=tid)
assert cielo_transaction.status == CieloTransactionStatus.Authorized
assert cielo_transaction.authorization_nsu == str(transacao.autorizacao.nsu)
assert cielo_transaction.authorization_lr == str(transacao.autorizacao.lr)
assert cielo_transaction.authorization_date == iso8601.parse_date(transacao.autorizacao.data_hora)
assert cielo_transaction.authentication_eci == transacao.autenticacao.eci
assert cielo_transaction.authentication_date == iso8601.parse_date(transacao.autenticacao.data_hora)
assert cielo_transaction.total_captured.value == Decimal()
assert cielo_transaction.total_reversed.value == Decimal()
order.refresh_from_db()
assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY)
assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY)
assert order.payment_status == PaymentStatus.NOT_PAID
def test_refresh_transaction_view(rf, admin_user):
initialize()
c = SmartClient()
default_product = get_default_product()
ORDER_TOTAL = PRODUCT_PRICE * 1
basket_path = reverse("shuup:basket")
c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
transaction_path = reverse("shuup:cielo_make_transaction")
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
c.get(confirm_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(numero=1,
valor=decimal_to_int_cents(ORDER_TOTAL),
produto=CieloProduct.Credit,
bandeira=CieloCardBrand.Visa,
parcelas=CC_VISA_1X_INFO['installments'],
tid=tid)
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
c.soup(payment_path)
c.post(transaction_path, CC_VISA_1X_INFO)
confirm_soup = c.soup(confirm_path)
c.post(confirm_path, data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key})
c.get(process_payment_path)
c.get(process_payment_return_path)
order.refresh_from_db()
cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order)
# transacao nao capturada
assert cielo_transaction.tid == tid
assert cielo_transaction.total_captured.value == Decimal()
view = load("shuup_cielo.admin.views.RefreshTransactionView").as_view()
request = apply_request_middleware(rf.post("/"), user=admin_user)
# request sem parametro - bad request
response = view(request)
assert response.status_code == 500
transacao = get_captured_transaction(transacao)
with patch.object(CieloRequest, 'consultar', return_value=transacao):
request = apply_request_middleware(rf.post("/", {"id":cielo_transaction.pk}), user=admin_user)
response = view(request)
assert response.status_code == 200
cielo_transaction.refresh_from_db()
assert cielo_transaction.total_captured_value == order.taxful_total_price_value
def _extract_fields(rf, user):
request = apply_request_middleware(rf.get("/"), user=user)
response = WizardView.as_view()(request)
response.render()
soup = BeautifulSoup(response.content)
return extract_form_fields(soup.find("form"))
def test_boleto_cecred_success():
"""
Usuário faz a compra e seleciona boleto como forma de pagamento (3 vezes seguidas)
Boleto CECRED configurado
"""
initialize()
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
assert isinstance(processor, BoletoPaymentProcessor)
choices = processor.get_service_choices()
assert len(choices) == 1
payment_method = processor.create_service(
BankService.CECRED.value,
identifier="cecred",
shop=get_default_shop(),
name="boleto cecred",
enabled=True,
tax_class=get_default_tax_class())
# Configura de acordo
behavior_component = payment_method.behavior_components.first()
behavior_component.local_pagamento = "a simple test"
behavior_component.cedente = "a simple user"
behavior_component.prazo_vencimento = 4
behavior_component.instrucoes = ["line1", "line2"]
behavior_component.especie_doc = DocumentType.DM
behavior_component.layout = 'v06'
behavior_component.agencia = '123431'
behavior_component.conta = '6427364732'
behavior_component.convenio = '123456'
behavior_component.carteira = '12'
behavior_component.save()
for ix in range(3):
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == ix
response = c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 200
# Phase: Confirm
assert Order.objects.count() == ix
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == ix+1
order = Order.objects.filter(payment_method=payment_method).first()
assert order.payment_status == PaymentStatus.NOT_PAID
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key})
assert response.url.endswith(process_payment_path), ("Confirm should have redirected to payment page")
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
order.refresh_from_db()
assert order.payment_status == PaymentStatus.NOT_PAID
from python_boleto.cecred import CecredBoleto
bcecred = CecredBoleto(**order.boleto.info)
bcecred.validate()
assert len(order.boleto.html) > 0
# "visualiza o boleto"
view_boleto_path = reverse("shuup:view_boleto", kwargs={"order_pk": order.pk, "order_key": order.key})
response = c.get(view_boleto_path)
assert HttpResponse(order.boleto.html).content == response.content
def test_product_edit_view(rf, admin_user, settings):
shop = get_default_shop() # obvious prerequisite
product = get_default_product()
shop_product = product.get_shop_instance(shop)
cat = CategoryFactory()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=product.pk)
response.render()
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content))
# Needed for Django 1.8 tests to pass
post.update({
'shop1-default_price_value': '42',
'images-TOTAL_FORMS': '0',
'media-TOTAL_FORMS': '0',
'base-name__fi': 'test',
'base-name__it': 'test',
'base-name__ja': 'test',
'base-name__pt-br': 'test',
'base-name__zh-hans': 'test',
})
post_data = {
'shop1-primary_category': [],
'shop1-categories': []
}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=product.pk)
shop_product.refresh_from_db()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
'shop1-default_price_value': 12,
'shop1-primary_category': [cat.pk],
'shop1-categories': []
}
post.update(post_data)
usable_post = {}
for k, v in six.iteritems(post):
if not k:
continue
if not post[k]:
continue
usable_post[k] = v
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
else:
assert not shop_product.categories.count()
assert shop_product.primary_category == cat
post_data = {
'shop1-primary_category': [],
'shop1-categories': []
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=product.pk)
# empty again
shop_product = ShopProduct.objects.first()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
'shop1-primary_category': [],
'shop1-categories': [cat.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
cat2 = CategoryFactory()
post_data = {
'shop1-primary_category': [],
'shop1-categories': [cat.pk, cat2.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 2
assert cat in shop_product.categories.all()
assert cat2 in shop_product.categories.all()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
def test_product_edit_view(rf, admin_user, settings):
shop = get_default_shop() # obvious prerequisite
shop.staff_members.add(admin_user)
parent = create_product("ComplexVarParent", shop=shop, supplier=get_default_supplier())
sizes = [("%sL" % ("X" * x)) for x in range(4)]
for size in sizes:
child = create_product(
"ComplexVarChild-%s" % size, shop=shop, supplier=get_default_supplier())
child.link_to_parent(parent, variables={"size": size})
shop_product = parent.get_shop_instance(shop)
cat = CategoryFactory()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
view = ProductEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request, pk=shop_product.pk)
response.render()
content = force_text(response.content)
post = extract_form_fields(BeautifulSoup(content, "lxml"))
# Needed for Django 1.8 tests to pass
post.update({
'shop1-default_price_value': '42',
'images-TOTAL_FORMS': '0',
'media-TOTAL_FORMS': '0',
'base-name__fi': 'test',
'base-name__it': 'test',
'base-name__ja': 'test',
'base-name__pt-br': 'test',
'base-name__zh-hans': 'test',
})
post_data = {
'shop1-primary_category': [],
'shop1-categories': []
}
post.update(post_data)
request = apply_request_middleware(rf.post("/", post), user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product.refresh_from_db()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
'shop1-default_price_value': 12,
'shop1-primary_category': cat.pk,
'shop1-categories': []
}
post.update(post_data)
usable_post = {}
for k, v in six.iteritems(post):
if not k:
continue
if not post[k]:
continue
usable_post[k] = v
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.primary_category
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
else:
assert not shop_product.categories.count()
assert shop_product.primary_category == cat
post_data = {
'shop1-primary_category': [],
'shop1-categories': []
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=shop_product.pk)
# empty again
shop_product = ShopProduct.objects.first()
assert not shop_product.categories.exists()
assert not shop_product.primary_category
post_data = {
'shop1-primary_category': [],
'shop1-categories': [cat.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 1
assert shop_product.categories.first() == cat
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
cat2 = CategoryFactory()
post_data = {
'shop1-primary_category': [],
'shop1-categories': [cat.pk, cat2.pk]
}
usable_post.update(post_data)
request = apply_request_middleware(rf.post("/", usable_post), user=admin_user)
response = view(request, pk=shop_product.pk)
shop_product = ShopProduct.objects.first()
assert shop_product.categories.count() == 2
assert cat in shop_product.categories.all()
assert cat2 in shop_product.categories.all()
if settings.SHUUP_AUTO_SHOP_PRODUCT_CATEGORIES:
assert shop_product.primary_category == cat
else:
assert not shop_product.primary_category
def test_credit_card_fail():
"""
Caso:
- Transação com Cartão de Crédito
- Auto captura desabilidato
- Sem URL para autenticação
- 4 parcelas
- dados do pagamento nao existem
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 10,
"supplier": get_default_supplier().pk
})
ORDER_TOTAL = PRODUCT_PRICE * 10
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
# aumenta o limite máximo de parcelas para 4
cielo_config = get_cielo_config()
cielo_config.max_installments = 4
cielo_config.save()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class()
)
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
transaction_path = reverse("shuup:cielo_make_transaction")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path, data={"payment_method": payment_method.pk, "shipping_method": shipping_method.pk})
c.get(confirm_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(1,
decimal_to_int_cents(ORDER_TOTAL),
CieloProduct.InstallmentCredit,
CieloCardBrand.Visa,
CC_VISA_4X_INFO['installments'],
tid,
return_url=None)
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: pay
c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_4X_INFO)
json_content = json.loads(response.content.decode("utf-8"))
response = c.post(json_content['redirect_url'])
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
# FORCE CLEAR ORDER PAYMENT DATA
order.payment_data = {}
order.save()
response = c.get(process_payment_path)
order.refresh_from_db()
assert order.status == OrderStatus.objects.get_default_canceled()
def test_checkout(admin_user):
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
create_test_data()
default_product = get_default_product()
sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop())
sp.default_price = get_default_shop().create_price(Decimal(10.0))
sp.save()
service = get_custom_carrier_service()
component = SpecificShippingTableBehaviorComponent.objects.create(
table=ShippingTable.objects.get(identifier='table-1')
)
service.behavior_components.add(component)
c = SmartClient()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
shipping_method = service
payment_method = get_payment_method(name="neat", price=4)
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
inputs['shipping-postal_code'] = "89060201"
inputs['shipping-country'] = "BR"
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 200
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == 1
order = Order.objects.filter(payment_method=payment_method).first()
assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_success_3():
"""
Caso:
- Transação com Cartão de Crédito
- Auto captura desabilidato
- Sem URL para autenticação
- 4 parcelas com juros
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 10,
"supplier": get_default_supplier().pk
})
ORDER_TOTAL = PRODUCT_PRICE * 10
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
# aumenta o limite máximo de parcelas para 4
cielo_config = get_cielo_config()
cielo_config.max_installments = 4
cielo_config.installments_without_interest = 1
cielo_config.interest_rate = Decimal(3.20)
cielo_config.save()
payment_method = processor.create_service(
CIELO_SERVICE_CREDIT,
identifier="cielo_phase_cc",
shop=get_default_shop(),
name="credit card",
enabled=True,
tax_class=get_default_tax_class())
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
transaction_path = reverse("shuup:cielo_make_transaction")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path,data={"payment_method": payment_method.pk,"shipping_method": shipping_method.pk})
c.get(confirm_path)
tid = uuid.uuid4().hex
transacao = get_in_progress_transaction(numero=1,
valor=decimal_to_int_cents(ORDER_TOTAL),
produto=CieloProduct.Credit,
bandeira=CieloCardBrand.Visa,
parcelas=CC_VISA_1X_INFO['installments'],
tid=tid,
return_url=None)
transacao = get_approved_transaction(transacao)
with patch.object(CieloRequest, 'autorizar', return_value=transacao):
with patch.object(CieloRequest, 'consultar', return_value=transacao):
# Phase: pay
c.soup(payment_path)
response = c.post(transaction_path, CC_VISA_4X_INFO)
assert response.status_code == 200
json_content = json.loads(response.content.decode("utf-8"))
assert json_content['redirect_url'].endswith(reverse("shuup:cielo_transaction_return",
kwargs={"cielo_order_pk": 1}))
choices = InstallmentContext(ORDER_TOTAL, cielo_config).get_intallments_choices()
cielo_transaction = CieloTransaction.objects.get(tid=tid)
assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit
assert abs(cielo_transaction.total_value - choices[3][2]) <= Decimal(0.01)
assert cielo_transaction.status.value == transacao.status
response = c.post(json_content['redirect_url'])
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
assert abs(order.taxful_total_price.value - choices[3][2]) <= Decimal(0.01)
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key})
response = c.get(process_payment_path)
response = c.get(process_payment_return_path)
cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order, tid=tid)
order.refresh_from_db()
assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY)
assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY)
assert order.payment_status == PaymentStatus.NOT_PAID
def test_boleto_cecred_error2():
"""
Usuário faz a compra e seleciona boleto como forma de pagamento
Boleto CECRED configurado incorretamente
Pedido finalizado com sucesso, boleto NÃO é gerado
"""
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
assert isinstance(processor, BoletoPaymentProcessor)
payment_method = processor.create_service(
BankService.CECRED.value,
identifier="cecred",
shop=get_default_shop(),
name="boleto cecred",
enabled=True,
tax_class=get_default_tax_class())
# Configura de acordo
behavior_component = payment_method.behavior_components.first()
behavior_component.local_pagamento = "a simple test"
behavior_component.cedente = "a simple user"
behavior_component.prazo_vencimento = 4
behavior_component.instrucoes = ["line1", "line2"]
behavior_component.especie_doc = DocumentType.DM
behavior_component.layout = 'v06'
behavior_component.agencia = '123431'
behavior_component.conta = '6427364732'
behavior_component.convenio = '32312'
behavior_component.carteira = '12'
behavior_component.save()
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 200
# quando vai gerar boleto estoura uma exceção
with patch.object(CecredBoletoBehaviorComponent, 'generate_boleto') as mocked:
mocked.side_effect = NotImplementedError()
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == 1
order = Order.objects.filter(payment_method=payment_method).first()
assert order.payment_status == PaymentStatus.NOT_PAID
process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key})
assert response.url.endswith(process_payment_path), ("Confirm should have redirected to payment page")
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
order.refresh_from_db()
assert order.payment_status == PaymentStatus.NOT_PAID
# BOLETO NÃO EXISTE
assert not hasattr(order, 'boleto')
assert not StoredBoleto.objects.filter(order=order).exists()
def test_new_user_information_edit(allow_image_uploads):
with override_settings(
SHUUP_CUSTOMER_INFORMATION_ALLOW_PICTURE_UPLOAD=allow_image_uploads
):
client = SmartClient()
get_default_shop()
# create new user
user_password = "******"
user = get_user_model().objects.create_user(
username="******",
email="*****@*****.**",
password=user_password,
first_name="Niilo",
last_name="Nyyppä",
)
client.login(username=user.username, password=user_password)
# make sure all information matches in form
customer_edit_url = reverse("shuup:customer_edit")
soup = client.soup(customer_edit_url)
assert soup.find(
attrs={"name": "contact-email"})["value"] == user.email
assert soup.find(
attrs={"name": "contact-first_name"})["value"] == user.first_name
assert soup.find(
attrs={"name": "contact-last_name"})["value"] == user.last_name
# Test POSTing
form = extract_form_fields(soup)
new_email = "*****@*****.**"
form["contact-email"] = new_email
form["contact-country"] = "FI"
for prefix in ("billing", "shipping"):
form["%s-city" % prefix] = "test-city"
form["%s-email" % prefix] = new_email
form["%s-street" % prefix] = "test-street"
form["%s-country" % prefix] = "FI"
if allow_image_uploads:
tmp_file = tempfile.NamedTemporaryFile(suffix='.jpg')
generate_image(120, 120).save(tmp_file)
with open(tmp_file.name, 'rb') as data:
response = client.post(reverse("shuup:media-upload"),
data=dict({"file": data}),
format="multipart")
assert response.status_code == 200
data = json.loads(response.content.decode("utf-8"))
file_id = data["file"]["id"]
form["contact-picture"] = file_id
response, soup = client.response_and_soup(customer_edit_url, form,
"post")
assert response.status_code == 302
user = get_user_model().objects.get(pk=user.pk)
assert user.email == new_email
contact = get_person_contact(user)
if allow_image_uploads:
assert contact.picture.id == file_id
# Fetch page and check that the picture rendered there
customer_edit_url = reverse("shuup:customer_edit")
soup = client.soup(customer_edit_url)
assert int(
soup.find(attrs={"id": "id_contact-picture-dropzone"})
["data-id"]) == file_id
else:
assert contact.picture is None
def test_order_flow_with_phases(get_shipping_method, shipping_data, get_payment_method, payment_data):
create_default_order_statuses()
populate_if_required()
c = SmartClient()
_populate_client_basket(c)
# Create methods
shipping_method = get_shipping_method()
payment_method = get_payment_method()
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
shipping_path = reverse("shuup:checkout", kwargs={"phase": "shipping"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth to methods"
# Phase: Methods
response = c.get(methods_path)
assert response.status_code == 200
response = c.post(
methods_path,
data={
"shipping_method": shipping_method.pk,
"payment_method": payment_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
# Phase: Shipping
response = c.get(shipping_path)
assert response.status_code == 200
response = c.post(shipping_path, data=shipping_data)
assert response.status_code == 302, "Payments phase should redirect forth"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
# Phase: payment
response = c.get(payment_path)
assert response.status_code == 200
response = c.post(payment_path, data=payment_data)
assert response.status_code == 302, "Payments phase should redirect forth"
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
order = Order.objects.first()
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
assert order.shipping_data.get("input_value") == "20540"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
assert order.payment_data.get("input_value")
assert order.payment_status == PaymentStatus.NOT_PAID
# Resolve order specific paths (payment and complete)
process_payment_path = reverse(
"shuup:order_process_payment",
kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse(
"shuup:order_process_payment_return",
kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse(
"shuup:order_complete",
kwargs={"pk": order.pk, "key": order.key})
# Check confirm redirection to payment page
assert response.url.endswith(process_payment_path), (
"Confirm should have redirected to payment page")
# Visit payment page
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
# Check payment return
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
# Check payment status has changed to DEFERRED
order = Order.objects.get(pk=order.pk) # reload
assert order.payment_status == PaymentStatus.DEFERRED
def create_success_order_with_boleto():
# Create methods
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
assert isinstance(processor, BoletoPaymentProcessor)
choices = processor.get_service_choices()
assert len(choices) == 1
payment_method = processor.create_service(
BankService.CECRED.value,
identifier="cecred",
shop=get_default_shop(),
name="boleto cecred",
enabled=True,
tax_class=get_default_tax_class())
# Configura de acordo
behavior_component = payment_method.behavior_components.first()
behavior_component.local_pagamento = "a simple test"
behavior_component.cedente = "a simple user"
behavior_component.prazo_vencimento = 4
behavior_component.instrucoes = ["line1", "line2"]
behavior_component.especie_doc = DocumentType.DM
behavior_component.layout = 'v06'
behavior_component.agencia = '123431'
behavior_component.conta = '6427364732'
behavior_component.convenio = '123456'
behavior_component.carteira = '12'
behavior_component.save()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
c.get(confirm_path)
confirm_soup = c.soup(confirm_path)
c.post(confirm_path, data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
process_payment_path = reverse("shuup:order_process_payment",
kwargs={
"pk": order.pk,
"key": order.key
})
process_payment_return_path = reverse("shuup:order_process_payment_return",
kwargs={
"pk": order.pk,
"key": order.key
})
order_complete_path = reverse("shuup:order_complete",
kwargs={
"pk": order.pk,
"key": order.key
})
c.get(process_payment_path)
c.get(process_payment_return_path)
c.get(order_complete_path)
order.refresh_from_db()
return order
def test_admin(rf, admin_user):
initialize()
c = SmartClient()
default_product = get_default_product()
basket_path = reverse("shuup:basket")
c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
shipping_method = get_default_shipping_method()
processor = get_payment_provider()
payment_method = processor.create_service(
PagSeguroPaymentMethod.ONLINE_DEBIT.value,
identifier="pagseguro_debit",
shop=get_default_shop(),
name="debit",
enabled=True,
tax_class=get_default_tax_class())
service_choices = processor.get_service_choices()
assert len(service_choices) == 2
assert service_choices[0].identifier == PagSeguroPaymentMethod.BOLETO.value
assert service_choices[
1].identifier == PagSeguroPaymentMethod.ONLINE_DEBIT.value
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
c.post(addresses_path, data=inputs)
c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
c.get(confirm_path)
c.soup(payment_path)
c.post(
payment_path, {
"paymentMethod":
PagSeguroPaymentMethodIdentifier.Debito,
"bankOption":
"{0}".format(PagSeguroPaymentMethodCode.DebitoOnlineBB.value),
"senderHash":
"J7E98Y37WEIRUHDIAI9U8RYE7UQE"
})
confirm_soup = c.soup(confirm_path)
c.post(confirm_path, data=extract_form_fields(confirm_soup))
order = Order.objects.filter(payment_method=payment_method).first()
payment = PagSeguroPayment.objects.create(order=order,
code="u3928uhu8y9i3")
PagSeguroOrderSection()
PagSeguroOrderSection.get_context_data(order)
assert PagSeguroOrderSection.visible_for_object(order) is True
view = load("shuup_pagseguro.admin.views.PaymentRefreshView").as_view()
request = apply_request_middleware(rf.post("/"), user=admin_user)
response = view(request)
assert response.status_code == 400
request = apply_request_middleware(rf.post("/", {"pk": payment.pk}),
user=admin_user)
response = view(request)
assert response.status_code == 200
# somente visita
view = load("shuup_pagseguro.admin.views.config.ConfigListView").as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request)
assert response.status_code == 200
view = load("shuup_pagseguro.admin.views.DashboardView").as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
response = view(request)
assert response.status_code == 200
def _extract_fields(rf, user):
request = apply_request_middleware(rf.get("/"), user=user)
response = WizardView.as_view()(request)
response.render()
soup = BeautifulSoup(response.content)
return extract_form_fields(soup.find("form"))