def test_mass_edit_orders3(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() contact1 = create_random_person() product1 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="50") product2 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="501") order1 = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0) order2 = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0) assert order1.status.role != OrderStatusRole.CANCELED assert order2.status.role != OrderStatusRole.CANCELED payload = { "action": OrderConfirmationPdfAction().identifier, "values": [order1.pk, order2.pk] } request = apply_request_middleware(rf.post( "/", user=admin_user, )) request._body = json.dumps(payload).encode("UTF-8") view = OrderListView.as_view() response = view(request=request) assert response.status_code == 200 if weasyprint: assert response['Content-Disposition'] == 'attachment; filename=order_confirmation_pdf.zip' else: assert response["content-type"] == "application/json"
def test_get_shipments(admin_user): client = _get_client(admin_user) shop1 = get_shop(True, name="teststore 1") shop2 = get_shop(True, name="teststore 2") customer1 = create_random_person() customer2 = create_random_person() order1 = create_random_order(customer1, shop=shop1, completion_probability=1) order2 = create_random_order(customer2, shop=shop1, completion_probability=1) order3 = create_random_order(customer1, shop=shop2, completion_probability=1) order4 = create_random_order(customer2, shop=shop1, completion_probability=1) # list shipments response = client.get("/api/shuup/shipment/") assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) assert len(shipment_data) == 4 assert shipment_data[0]["id"] == order1.shipments.first().pk assert shipment_data[1]["id"] == order2.shipments.first().pk assert shipment_data[2]["id"] == order3.shipments.first().pk assert shipment_data[3]["id"] == order4.shipments.first().pk # get shipment by id response = client.get("/api/shuup/shipment/%s/" % order1.shipments.first().pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) assert shipment_data["id"] == order1.shipments.first().pk assert shipment_data["order"] == order1.pk # get shipment by product product = order2.shipments.first().products.first().product response = client.get("/api/shuup/shipment/?product=%s" % product.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: assert ship["products"][0]["product"] == product.pk # get shipment by order response = client.get("/api/shuup/shipment/?order=%s" % order3.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: assert ship["order"] == order3.pk # get shipment by shop response = client.get("/api/shuup/shipment/?shop=%s" % shop1.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: assert Shipment.objects.filter(pk=ship["id"], order__shop=shop1).exists()
def test_total_sales_customers_report(rf): shop = get_default_shop() supplier = get_default_supplier(shop) p1 = create_product("p1", shop=shop, supplier=supplier, default_price="5") p2 = create_product("p2", shop=shop, supplier=supplier, default_price="20") # orders for person 1 person1 = create_random_person() order1 = create_random_order(customer=person1, completion_probability=1, products=[p1, p2]) order2 = create_random_order(customer=person1, completion_probability=1, products=[p1, p2]) # orders for person 2 person2 = create_random_person() order3 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) order4 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) order5 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) # pay orders [o.create_payment(o.taxful_total_price) for o in Order.objects.all()] data = { "report": TotalSales.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.ALL_TIME, "writer": "json", "force_download": 1, } report = TotalSales(**data) writer = get_writer_instance(data["writer"]) response = writer.get_response(report=report) if hasattr(response, "render"): response.render() json_data = json.loads(response.content.decode("utf-8")) assert force_text(TotalSales.title) in json_data.get("heading") data = json_data.get("tables")[0].get("data")[0] avg_sales = (order1.taxful_total_price + order2.taxful_total_price + order3.taxful_total_price + order4.taxful_total_price + order5.taxful_total_price) / Decimal(5) assert int(data["customers"]) == 2 assert int(data["order_amount"]) == 5 assert data["customer_avg_sale"] == str( avg_sales.value.quantize(Decimal('0.01')))
def test_list_orders(admin_user): shop = get_default_shop() product = create_product("test", shop, get_default_supplier()) order = create_random_order(get_person_contact(admin_user), [product]) order2 = create_random_order(create_random_person(), [product]) client = _get_client(admin_user) response = client.get("/api/shuup/front/orders/") response_data = json.loads(response.content.decode("utf-8")) assert response.status_code == status.HTTP_200_OK assert len(response_data) == 1 assert "shop" in response_data[0] assert "contact_address" in response_data[0]["shop"]
def test_get_shipments(admin_user): client = _get_client(admin_user) shop1 = get_shop(True) shop2 = get_shop(True) customer1 = create_random_person() customer2 = create_random_person() order1 = create_random_order(customer1, shop=shop1, completion_probability=1) order2 = create_random_order(customer2, shop=shop1, completion_probability=1) order3 = create_random_order(customer1, shop=shop2, completion_probability=1) order4 = create_random_order(customer2, shop=shop1, completion_probability=1) # list shipments response = client.get("/api/shuup/shipment/") assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) assert len(shipment_data) == 4 assert shipment_data[0]["id"] == order1.shipments.first().pk assert shipment_data[1]["id"] == order2.shipments.first().pk assert shipment_data[2]["id"] == order3.shipments.first().pk assert shipment_data[3]["id"] == order4.shipments.first().pk # get shipment by id response = client.get("/api/shuup/shipment/%s/" % order1.shipments.first().pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) assert shipment_data["id"] == order1.shipments.first().pk assert shipment_data["order"] == order1.pk # get shipment by product product = order2.shipments.first().products.first() response = client.get("/api/shuup/shipment/?product=%s" % product.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: for ship_product in shipment_data["product"]: assert ship_product["id"] == product.pk assert ship_product["order"] == order2.pk # get shipment by order response = client.get("/api/shuup/shipment/?order=%s" % order3.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: assert ship["order"] == order3.pk # get shipment by shop response = client.get("/api/shuup/shipment/?shop=%s" % shop1.pk) assert response.status_code == status.HTTP_200_OK shipment_data = json.loads(response.content.decode("utf-8")) for ship in shipment_data: assert Shipment.objects.filter(pk=ship["id"], order__shop=shop1).exists()
def test_order_received(rf, regular_user): activate("en") get_default_product() get_default_supplier() get_test_script("test script", "order_received") template_data = STEP_DATA[0]["actions"][0]["template_data"] for lang in ["en", "fi"]: n_outbox_pre = len(mail.outbox) customer = create_random_person(locale=lang) create_random_order(customer) assert (len(mail.outbox) == n_outbox_pre + 1), "Sending email failed" latest_mail = mail.outbox[-1] 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_delete_payment(admin_user, rf): product = get_default_product() shop_product = product.get_shop_instance(get_default_shop()) shop_product.default_price_value = 20 shop_product.save() order = create_random_order(customer=create_random_person(), products=(product,), completion_probability=0) payment_amount = order.taxful_total_price_value # create a payment view = OrderCreatePaymentView.as_view() request = apply_request_middleware(rf.post("/", {"amount": payment_amount}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code == 302 order.refresh_from_db() assert order.is_paid() # delete the payment payment = order.payments.last() view = OrderDeletePaymentView.as_view() request = apply_request_middleware(rf.post("/", {"payment": payment.pk}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code == 302 order.refresh_from_db() assert order.is_not_paid()
def test_protected_fields(): activate("en") shop = Shop.objects.create( name="testshop", identifier="testshop", status=ShopStatus.ENABLED, public_name="test shop", domain="derp", currency="EUR" ) get_currency("EUR") get_currency("USD") assert shop.name == "testshop" assert shop.currency == "EUR" assert not ConfigurationItem.objects.filter(shop=shop, key="languages").exists() shop_form = ShopBaseForm(instance=shop, languages=settings.LANGUAGES) assert not shop_form._get_protected_fields() # No protected fields just yet, right? data = get_form_data(shop_form, prepared=True) shop_form = ShopBaseForm(data=data, instance=shop, languages=settings.LANGUAGES) _test_cleanliness(shop_form) shop_form.save() # Now let's make it protected! create_product(printable_gibberish(), shop=shop, supplier=get_default_supplier()) order = create_random_order(customer=create_random_person(), shop=shop) assert order.shop == shop # And try again... data["currency"] = "USD" shop_form = ShopBaseForm(data=data, instance=shop, languages=settings.LANGUAGES) assert shop_form._get_protected_fields() # So protected! _test_cleanliness(shop_form) shop = shop_form.save() assert shop.currency == "EUR" # But the shop form ignored the change . . .
def test_order_creator_customer_details(rf, admin_user): shop = get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) company = create_random_company() group = get_default_customer_group() contact.groups.add(group) contact.company_memberships.add(company) contact.save() product = create_product(sku=printable_gibberish(), supplier=get_default_supplier(), shop=shop) order = create_random_order(contact, products=[product]) request = apply_request_middleware(rf.get("/", {"command": "customer_details", "id": contact.id}), user=admin_user) response = OrderEditView.as_view()(request) data = json.loads(response.content.decode("utf8")) assert "customer_info" in data assert "order_summary" in data assert "recent_orders" in data assert data["customer_info"]["name"] == contact.full_name assert data["customer_info"]["phone_no"] == contact.phone assert data["customer_info"]["email"] == contact.email assert company.full_name in data["customer_info"]["companies"] assert group.name in data["customer_info"]["groups"] assert data["customer_info"]["merchant_notes"] == contact.merchant_notes assert len(data["order_summary"]) == 1 assert data["order_summary"][0]["year"] == order.order_date.year assert data["order_summary"][0]["total"] == format_money(order.taxful_total_price) assert len(data["recent_orders"]) == 1 assert data["recent_orders"][0]["status"] == order.get_status_display() assert data["recent_orders"][0]["total"] == format_money(order.taxful_total_price) assert data["recent_orders"][0]["payment_status"] == force_text(order.payment_status.label) assert data["recent_orders"][0]["shipment_status"] == force_text(order.shipping_status.label)
def test_coupon_amount_limit(): coupon = Coupon.objects.create(code="TEST", active=True) get_default_campaign(coupon) contact = create_random_person() shop = get_default_shop() product = create_product("test", shop=shop, supplier=get_default_supplier(), default_price="12") order = create_random_order(customer=contact) for x in range(50): coupon.use(order) assert coupon.usages.count() == 50 coupon.increase_usage_limit_by(5) coupon.save() assert coupon.usage_limit == 55 assert coupon.can_use_code(contact) for x in range(5): coupon.use(order) assert coupon.usages.count() == 55 assert not Coupon.is_usable(coupon.code, order.customer) assert coupon.usages.count() == 55 # no change, limit met
def test_mass_edit_orders(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() contact1 = create_random_person() product1 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="50") product2 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="501") order = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0) assert order.status.role != OrderStatusRole.CANCELED payload = { "action": CancelOrderAction().identifier, "values": [order.pk] } request = apply_request_middleware(rf.post( "/", user=admin_user, )) request._body = json.dumps(payload).encode("UTF-8") view = OrderListView.as_view() response = view(request=request) assert response.status_code == 200 for order in Order.objects.all(): assert order.status.role == OrderStatusRole.CANCELED
def test_order_chart_works(rf, admin_user): get_default_shop() order = create_random_order(customer=create_random_person(), products=(get_default_product(), )) request = apply_request_middleware(rf.get("/"), user=admin_user) chart = OrderValueChartDashboardBlock("test", request=request).get_chart() assert len(chart.datasets[0]) > 0
def test_retrieve_order(admin_user): shop = get_default_shop() product = create_product("test", shop, get_default_supplier()) order = create_random_order(get_person_contact(admin_user), [product]) order2 = create_random_order(create_random_person(), [product]) client = _get_client(admin_user) response = client.get("/api/shuup/front/orders/{}/".format(order.pk)) response_data = json.loads(response.content.decode("utf-8")) assert response.status_code == status.HTTP_200_OK assert response_data["id"] == order.pk response = client.get("/api/shuup/front/orders/{}/".format(100)) assert response.status_code == 404 response = client.get("/api/shuup/front/orders/{}/".format(order2.pk)) assert response.status_code == 404
def test_mass_edit_orders4(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() contact1 = create_random_person() product1 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="50") product2 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="501") order = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0) assert order.status.role != OrderStatusRole.CANCELED payload = {"action": OrderDeliveryPdfAction().identifier, "values": [order.pk]} request = apply_request_middleware(rf.post("/"), user=admin_user) request._body = json.dumps(payload).encode("UTF-8") view = OrderListView.as_view() response = view(request=request) assert response.status_code == 200 assert response["content-type"] == "application/json" order.create_shipment_of_all_products(supplier) order.save() request._body = json.dumps(payload).encode("UTF-8") view = OrderListView.as_view() response = view(request=request) assert response.status_code == 200 if weasyprint: assert response["Content-Disposition"] == "attachment; filename=shipment_%s_delivery.pdf" % order.pk else: assert response["content-type"] == "application/json"
def get_order_for_date(dt, product): order = create_random_order(customer=create_random_person(), products=[product]) order.order_date = to_aware(dt) order.status = OrderStatus.objects.get_default_complete() order.save() return order
def test_mass_edit_orders(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() contact1 = create_random_person() product1 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="50") product2 = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="501") order = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0) assert order.status.role != OrderStatusRole.CANCELED payload = {"action": CancelOrderAction().identifier, "values": [order.pk]} request = apply_request_middleware(rf.post( "/", user=admin_user, )) request._body = json.dumps(payload).encode("UTF-8") view = OrderListView.as_view() response = view(request=request) assert response.status_code == 200 for order in Order.objects.all(): assert order.status.role == OrderStatusRole.CANCELED
def get_initialized_test_event(): get_default_product() customer = create_random_person() order = create_random_order(customer) return ATestEvent(order_language=order.language, order=order, just_some_text=random_title())
def test_total_sales_customers_report(rf): shop = get_default_shop() supplier = get_default_supplier() p1 = create_product("p1", shop=shop, supplier=supplier, default_price="5") p2 = create_product("p2", shop=shop, supplier=supplier, default_price="20") # orders for person 1 person1 = create_random_person() order1 = create_random_order(customer=person1, completion_probability=1, products=[p1, p2]) order2 = create_random_order(customer=person1, completion_probability=1, products=[p1, p2]) # orders for person 2 person2 = create_random_person() order3 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) order4 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) order5 = create_random_order(customer=person2, completion_probability=1, products=[p1, p2]) # pay orders [o.create_payment(o.taxful_total_price) for o in Order.objects.all()] data = { "report": TotalSales.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.ALL_TIME, "writer": "json", "force_download": 1, } report = TotalSales(**data) writer = get_writer_instance(data["writer"]) response = writer.get_response(report=report) if hasattr(response, "render"): response.render() json_data = json.loads(response.content.decode("utf-8")) assert force_text(TotalSales.title) in json_data.get("heading") data = json_data.get("tables")[0].get("data")[0] avg_sales = ( order1.taxful_total_price + order2.taxful_total_price + order3.taxful_total_price + order4.taxful_total_price + order5.taxful_total_price ) / Decimal(5) assert int(data["customers"]) == 2 assert int(data["order_amount"]) == 5 assert data["customer_avg_sale"] == str(avg_sales.value.quantize(Decimal('0.01')))
def mock_order_6h(self, **kwargs): """ Create a random order for past 6h (20% chance for completion)""" shop = kwargs.pop("shop") try: return create_random_order(completion_probability=0.2, shop=shop) except Exception as e: pass
def mock_order(self, **kwargs): """ Create a random order (randomly completed)""" shop = kwargs.pop("shop") try: return create_random_order(completion_probability=0.6, shop=shop) except Exception as e: pass
def get_initialized_test_event(): get_default_product() customer = create_random_person() order = create_random_order(customer) return ATestEvent( order_language=order.language, order=order, just_some_text=random_title() )
def mock_fully_paid_order_30d(self, **kwargs): """ Create a random order for past 30 days (complete and fully paid).""" shop = kwargs.pop("shop") order_date = now() - datetime.timedelta(hours=random.uniform(0, 720)) try: return create_random_order( completion_probability=1, shop=shop, create_payment_for_order_total=True, order_date=order_date) except Exception: pass
def mock_fully_paid_order(self, **kwargs): """ Create a random order (complete and fully paid).""" shop = kwargs.pop("shop") try: return create_random_order( completion_probability=1, shop=shop, create_payment_for_order_total=True) except Exception: pass
def test_serialize_data(): """ Test contact dashboard views """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") user = factories.create_random_user("en") user.set_password("1234") user.save() customer.user = user customer.default_billing_address = factories.create_random_address() customer.default_shipping_address = factories.create_random_address() customer.save() company = factories.create_random_company() company.default_billing_address = factories.create_random_address() company.default_shipping_address = factories.create_random_address() company.save() company.members.add(customer) product = factories.create_product("p1", shop, factories.get_default_supplier()) for basket_customer in [customer, company]: [ factories.create_random_order(basket_customer, [product]) for order in range(3) ] client = SmartClient() client.login(username=user.username, password="******") response = client.get(reverse("shuup:gdpr_customer_dashboard")) assert response.status_code == 200 assert "My Data" in response.content.decode("utf-8") response = client.post(reverse("shuup:gdpr_download_data")) assert response._headers["content-disposition"][0] == "Content-Disposition" assert response.status_code == 200 from shuup.tasks.models import Task, TaskType from shuup.gdpr.models import GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER response = client.post(reverse("shuup:gdpr_anonymize_account")) assert response.status_code == 302 assert response.url.endswith(reverse("shuup:index")) task_type = TaskType.objects.get( identifier=GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER, shop=shop) assert Task.objects.get(type=task_type, shop=shop) user.refresh_from_db() assert user.is_active is False refreshed_customer = PersonContact.objects.get(id=customer.id) assert refreshed_customer.is_active is False assert refreshed_customer.name == customer.name # nothing changed yet
def test_add_order_log_entry(admin_user, rf): order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) assert not OrderLogEntry.objects.filter(target=order).exists() view = NewLogEntryView.as_view() test_message = "test_order" request = apply_request_middleware(rf.post("/", {"message": test_message}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code < 400 assert OrderLogEntry.objects.filter(target=order).exists() assert OrderLogEntry.objects.filter(target=order).first().message == test_message
def test_update_order_admin_comment(admin_user, rf): order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) assert order.admin_comment == "" view = UpdateAdminCommentView.as_view() comment = "updated admin comment" request = apply_request_middleware(rf.post("/", {"comment": comment}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code < 400 order.refresh_from_db() assert order.admin_comment == comment
def test_order_set_status_canceled_works(admin_user, rf): order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) assert order.shipping_status == ShippingStatus.NOT_SHIPPED assert order.status.role == OrderStatusRole.INITIAL canceled_status = OrderStatus.objects.get_default_canceled() view = OrderSetStatusView.as_view() request = apply_request_middleware(rf.post("/", {"status": canceled_status.pk}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code < 400 order = Order.objects.get(pk=order.pk) assert order.status_id == canceled_status.id assert order.log_entries.filter(identifier="status_change").exists()
def test_order_set_status_completed_works(admin_user, rf): order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) order.create_shipment_of_all_products() # Need to be shipped to set complete assert order.status.role == OrderStatusRole.INITIAL complete_status = OrderStatus.objects.get_default_complete() view = OrderSetStatusView.as_view() request = apply_request_middleware(rf.post("/", {"status": complete_status.pk}), user=admin_user) response = view(request, pk=order.pk) assert response.status_code < 400 order = Order.objects.get(pk=order.pk) assert order.status_id == complete_status.id assert order.log_entries.filter(identifier="status_change").exists()
def test_serialize_data(): """ Test contact dashboard views """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") user = factories.create_random_user("en") user.set_password("1234") user.save() customer.user = user customer.default_billing_address = factories.create_random_address() customer.default_shipping_address = factories.create_random_address() customer.save() company = factories.create_random_company() company.default_billing_address = factories.create_random_address() company.default_shipping_address = factories.create_random_address() company.save() company.members.add(customer) product = factories.create_product("p1", shop, factories.get_default_supplier()) for basket_customer in [customer, company]: [factories.create_random_order(basket_customer, [product]) for order in range(3)] client = SmartClient() client.login(username=user.username, password="******") response = client.get(reverse("shuup:gdpr_customer_dashboard")) assert response.status_code == 200 assert "My Data" in response.content.decode("utf-8") response = client.post(reverse("shuup:gdpr_download_data")) assert response._headers["content-disposition"][0] == "Content-Disposition" assert response.status_code == 200 from shuup.tasks.models import Task, TaskType from shuup.gdpr.models import GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER response = client.post(reverse("shuup:gdpr_anonymize_account")) assert response.status_code == 302 assert response.url.endswith(reverse("shuup:index")) task_type = TaskType.objects.get(identifier=GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER, shop=shop) assert Task.objects.get(type=task_type, shop=shop) user.refresh_from_db() assert user.is_active is False refreshed_customer = PersonContact.objects.get(id=customer.id) assert refreshed_customer.is_active is False assert refreshed_customer.name == customer.name # nothing changed yet
def test_recent_orders_block(rf, admin_user): with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=True): shop1 = get_default_shop() shop2 = get_shop(identifier="shop2", status=ShopStatus.ENABLED, name="Shop2") order = create_random_order(customer=create_random_person(), products=[get_default_product()]) for shop in [shop1, shop2]: request = apply_request_middleware(rf.get("/"), user=admin_user, shop=shop) block = get_recent_orders_block(request) if shop == shop1: assert order.customer.name in block.content else: assert order.customer.name not in block.content
def setUp(self): OrderStatusManager().ensure_default_statuses() product = factories.create_product("p", factories.get_default_shop(), factories.get_default_supplier()) customer = factories.create_random_person() # Initial Order intial_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.INITIAL.value).first() self.order_initial = factories.create_random_order(customer=customer, products=[product]) self.order_initial.change_status(intial_status) # Processing Order process_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.PROCESSING.value).first() self.order_processing = factories.create_random_order(customer=customer, products=[product]) self.order_processing.change_status(process_status) # Complete Order complete_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.COMPLETE.value).first() self.order_complete = factories.create_random_order(customer=customer, products=[product]) self.order_complete.change_status(complete_status) # Canceled Order canceled_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.CANCELED.value).first() self.order_canceled = factories.create_random_order(customer=customer, products=[product]) self.order_canceled.change_status(canceled_status)
def test_recent_orders_block(rf, admin_user): with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=True): shop1 = get_default_shop() shop2 = get_shop(identifier="shop2", status=ShopStatus.ENABLED, name="Shop2") customer = create_random_person() # prevent weird names with random chars customer.name = "Jon Doe" customer.save() order = create_random_order(customer=customer, products=[get_default_product()]) for shop in [shop1, shop2]: request = apply_request_middleware(rf.get("/"), user=admin_user, shop=shop) block = get_recent_orders_block(request) if shop == shop1: assert order.customer.name in block.content else: assert order.customer.name not in block.content
def test_serialize_data(): """ Test contact dashboard views """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") user = factories.create_random_user("en") user.set_password("1234") user.save() customer.user = user customer.default_billing_address = factories.create_random_address() customer.default_shipping_address = factories.create_random_address() customer.save() company = factories.create_random_company() company.default_billing_address = factories.create_random_address() company.default_shipping_address = factories.create_random_address() company.save() company.members.add(customer) product = factories.create_product("p1", shop, factories.get_default_supplier()) for basket_customer in [customer, company]: [ factories.create_random_order(basket_customer, [product]) for order in range(3) ] client = SmartClient() client.login(username=user.username, password="******") response = client.get(reverse("shuup:gdpr_customer_dashboard")) assert response.status_code == 200 assert "My Data" in response.content.decode("utf-8") response = client.post(reverse("shuup:gdpr_download_data")) assert response._headers["content-disposition"][0] == "Content-Disposition" assert response.status_code == 200 response = client.post(reverse("shuup:gdpr_anonymize_account")) assert response.status_code == 302 assert response.url.endswith(reverse("shuup:index"))
def test_gdpr_admin_download_data(client, admin_user): """ Test that admin user can download customer data """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") product = factories.create_product("p1", shop, factories.get_default_supplier()) [factories.create_random_order(customer, [product]) for order in range(3)] client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_download_url = reverse("shuup_admin:gdpr.download_data", kwargs=dict(pk=customer.pk)) response = client.post(admin_download_url) assert response.status_code == 200 assert response._headers["content-disposition"][0] == "Content-Disposition" assert response._headers["content-disposition"][1].startswith("attachment; filename=user_data_")
def test_order_creator_customer_details(rf, admin_user): shop = get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) company = create_random_company() group = get_default_customer_group() contact.groups.add(group) contact.company_memberships.add(company) contact.save() product = create_product(sku=printable_gibberish(), supplier=get_default_supplier(), shop=shop) order = create_random_order(contact, products=[product]) request = apply_request_middleware(rf.get( "/", { "command": "customer_details", "id": contact.id }), user=admin_user) response = OrderEditView.as_view()(request) data = json.loads(response.content.decode("utf8")) assert "customer_info" in data assert "order_summary" in data assert "recent_orders" in data assert data["customer_info"]["name"] == contact.full_name assert data["customer_info"]["phone_no"] == contact.phone assert data["customer_info"]["email"] == contact.email assert company.full_name in data["customer_info"]["companies"] assert group.name in data["customer_info"]["groups"] assert data["customer_info"]["merchant_notes"] == contact.merchant_notes assert len(data["order_summary"]) == 1 assert data["order_summary"][0]["year"] == order.order_date.year assert data["order_summary"][0]["total"] == format_money( order.taxful_total_price) assert len(data["recent_orders"]) == 1 assert data["recent_orders"][0]["status"] == order.get_status_display() assert data["recent_orders"][0]["total"] == format_money( order.taxful_total_price) assert data["recent_orders"][0]["payment_status"] == force_text( order.payment_status.label) assert data["recent_orders"][0]["shipment_status"] == force_text( order.shipping_status.label)
def test_gdpr_admin_download_data(client, admin_user): """ Test that admin user can download customer data """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") product = factories.create_product("p1", shop, factories.get_default_supplier()) [factories.create_random_order(customer, [product]) for order in range(3)] client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_download_url = reverse("shuup_admin:gdpr.download_data", kwargs=dict(pk=customer.pk)) response = client.post(admin_download_url) assert response.status_code == 200 assert response._headers["content-disposition"][0] == "Content-Disposition" assert response._headers["content-disposition"][1].startswith( "attachment; filename=user_data_")
def test_order_chart_works(rf, admin_user): get_default_shop() order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) request = apply_request_middleware(rf.get("/"), user=admin_user) chart = OrderValueChartDashboardBlock("test", request=request).get_chart() assert len(chart.datasets[0]) > 0
def test_recent_orders_block(rf): order = create_random_order(customer=create_random_person(), products=[get_default_product()]) block = get_recent_orders_block(rf.get("/"), DEFAULT_CURRENCY) assert html.escape(order.customer.name) in block.content
def get_order_for_date(dt, product): order = create_random_order(customer=create_random_person(), products=[product]) order.order_date = dt order.status = OrderStatus.objects.get_default_complete() order.save() return order
def mock_order(self): """ Create a random order """ return create_random_order(completion_probability=0.8)
def test_shop_api(admin_user, currency, currency_decimals): activate("en") default_shop = get_default_shop() client = APIClient() client.force_authenticate(user=admin_user) Currency.objects.get_or_create(code=currency, decimal_places=currency_decimals) shop_data = { "domain": "shuup.com", "status": ShopStatus.ENABLED.value, "owner": create_random_person().pk, "currency": currency, "prices_include_tax": True, "maintenance_mode": False, "translations":{ "en": { "name": "Store 1", "public_name": "Public Store 1" } } } response = client.post("/api/shuup/shop/", content_type="application/json", data=json.dumps(shop_data)) assert response.status_code == status.HTTP_201_CREATED shop = Shop.objects.exclude(pk=default_shop.pk).first() assert shop.domain == shop_data["domain"] assert shop.status.value == shop_data["status"] assert shop.owner.pk == shop_data["owner"] assert shop.currency == shop_data["currency"] assert shop.maintenance_mode == shop_data["maintenance_mode"] assert shop.prices_include_tax == shop_data["prices_include_tax"] assert shop.name == shop_data["translations"]["en"]["name"] assert shop.public_name == shop_data["translations"]["en"]["public_name"] shop_data["domain"] = "cloud.shuup.com" response = client.put("/api/shuup/shop/%d/" % shop.id, content_type="application/json", data=json.dumps(shop_data)) assert response.status_code == status.HTTP_200_OK shop = Shop.objects.exclude(pk=default_shop.pk).first() assert shop.domain == shop_data["domain"] response = client.get("/api/shuup/shop/%d/" % shop.id) assert response.status_code == status.HTTP_200_OK data = json.loads(response.content.decode("utf-8")) assert shop.domain == data["domain"] assert shop.status.value == data["status"] assert shop.owner.pk == data["owner"] assert shop.currency == data["currency"]["code"] assert data["currency"]["symbol"] == babel.numbers.get_currency_symbol(shop.currency, get_current_babel_locale()) assert data["currency"]["decimal_places"] == currency_decimals assert shop.maintenance_mode == data["maintenance_mode"] assert shop.prices_include_tax == data["prices_include_tax"] assert shop.name == data["translations"]["en"]["name"] assert shop.public_name == data["translations"]["en"]["public_name"] response = client.get("/api/shuup/shop/") assert response.status_code == status.HTTP_200_OK data = json.loads(response.content.decode("utf-8")) assert shop.domain == data[1]["domain"] response = client.delete("/api/shuup/shop/%d/" % shop.id) assert response.status_code == status.HTTP_204_NO_CONTENT assert Shop.objects.count() == 1 # shouldn't be possible to delete a shop with a related order product = create_product("product1", shop=default_shop, supplier=get_default_supplier()) create_random_order(create_random_person(), [product], completion_probability=1, shop=default_shop) response = client.delete("/api/shuup/shop/%d/" % default_shop.id) assert response.status_code == status.HTTP_400_BAD_REQUEST assert "This object can not be deleted because it is referenced by" in response.content.decode("utf-8") assert Shop.objects.count() == 1
def test_reorder_view(): shop = factories.get_default_shop() factories.get_default_shipping_method() factories.get_default_payment_method() supplier1 = factories.get_supplier(SimpleSupplierModule.identifier, shop=shop) supplier2 = factories.get_supplier(SimpleSupplierModule.identifier, shop=shop) assert supplier1.pk != supplier2.pk product_supplier1 = factories.create_product( "product_supplier1", shop=shop, supplier=supplier1, default_price=10, shipping_mode=ShippingMode.NOT_SHIPPED) product_supplier2 = factories.create_product( "product_supplier2", shop=shop, supplier=supplier2, default_price=20, shipping_mode=ShippingMode.NOT_SHIPPED) user = factories.create_random_user("en") user.set_password("user") user.save() customer = factories.create_random_person("en") customer.user = user customer.save() order = factories.create_random_order( customer=customer, shop=shop, products=[product_supplier1, product_supplier2], completion_probability=0, random_products=False) suppliers = [line.supplier for line in order.lines.products()] assert supplier1 in suppliers assert supplier2 in suppliers client = Client() client.login(username=user.username, password="******") # list orders response = client.get(reverse("shuup:personal-orders")) assert response.status_code == 200 content = response.content.decode("utf-8") assert "<td>%d</td>" % order.id in content assert "<td>Received</td>" in content # go to order detail response = client.get(reverse("shuup:show-order", kwargs=dict(pk=order.pk))) assert response.status_code == 200 content = response.content.decode("utf-8") assert "Add all products to cart" in content reorder_url = reverse("shuup:reorder-order", kwargs=dict(pk=order.pk)) assert reorder_url in content # reorder products response = client.get(reorder_url) assert response.status_code == 302 assert response.url.endswith(reverse("shuup:basket")) # go to basket response = client.get(response.url) assert response.status_code == 200 content = response.content.decode("utf-8") # ensure the basket contain those products and suppliers basket_key = client.session["basket_basket_key"]["key"] from shuup.front.models import StoredBasket basket = StoredBasket.objects.get(key=basket_key) lines = basket.data["lines"] product_supplier = [(line["product_id"], line["supplier_id"]) for line in lines] assert (product_supplier1.pk, supplier1.pk) in product_supplier assert (product_supplier2.pk, supplier2.pk) in product_supplier assert product_supplier1.name in content assert product_supplier2.name in content assert "You are unable to proceed to checkout!" not in content
data = { "model": model_name, "id": object_id } if mode: data["mode"] = mode request = apply_request_middleware(rf.get(reverse("shuup_admin:edit"), data), user=user, shop=shop) return view(request) @pytest.mark.parametrize("creator_fn", [ lambda: factories.create_product("sku", factories.get_default_shop(), factories.get_default_supplier()), lambda: factories.create_random_person(), lambda: factories.create_random_company(), lambda: factories.create_random_order(customer=factories.create_random_person(), products=[ factories.create_product("p", factories.get_default_shop(), factories.get_default_supplier()) ]), lambda: factories.create_random_user(), ]) @pytest.mark.django_db def test_edit_object_view(rf, admin_user, creator_fn): shop = factories.get_default_shop() view = EditObjectView.as_view() object_instance = creator_fn() model = ".".join(ContentType.objects.get_for_model(object_instance).natural_key()) # correct shop response = _get_edit_object_view(rf, view, model, object_instance.id, admin_user, shop) assert response.status_code == 302 urls = []
def test_order_received_variables(rf, with_shop_contact): activate("en") shop = get_shop(True) shop.contact_address = get_address(**SHOP_ADDRESS_DATA) shop.contact_address.save() shop.save() get_default_product() get_default_supplier() STEP_DATA = [{ "cond_op": "all", "enabled": True, "next": "continue", "actions": [{ "template_data": { "en": { "body": "{{ customer_email }}", "content_type": "plain", "subject": "{{ customer_phone }}" } }, "identifier": "send_email", "language": { "constant": "en" }, "recipient": { "constant": "*****@*****.**" } }] }] if with_shop_contact: STEP_DATA[0]['actions'].insert(0, { "template_data": { "en": { "body": "{{ shop_email }}", "content_type": "plain", "subject": "{{ shop_phone }}" } }, "identifier": "send_email", "language": { "constant": "en" }, "recipient": { "constant": "*****@*****.**" } }) sc = Script.objects.create( name="variables script", event_identifier="order_received", enabled=True, shop=shop) sc.set_serialized_steps(STEP_DATA) sc.save() n_outbox_pre = len(mail.outbox) customer = create_random_person(locale='en') customer.default_shipping_address = get_address(**DEFAULT_ADDRESS_DATA) customer.default_shipping_address.save() customer.save() create_random_order(customer, shop=shop) assert (len(mail.outbox) == n_outbox_pre + (2 if with_shop_contact else 1)), "Sending email failed" latest_mail = mail.outbox[-1] assert latest_mail.subject == customer.default_shipping_address.phone assert latest_mail.body == customer.default_shipping_address.email if with_shop_contact: # shop email is sent first - we use insert(0, shop_step_data) penult_mail = mail.outbox[-2] assert penult_mail.subject == shop.contact_address.phone assert penult_mail.body == shop.contact_address.email
def test_order_chart_works(): order = create_random_order(customer=create_random_person(), products=(get_default_product(),)) chart = OrderValueChartDashboardBlock("test", order.currency).get_chart() assert len(chart.series[0]) > 0
def test_retrieve_order(admin_user): shop = get_default_shop() product = create_product("test", shop, get_default_supplier()) order = create_random_order(get_person_contact(admin_user), [product]) order2 = create_random_order(create_random_person(), [product]) client = _get_client(admin_user) for (index, line) in enumerate(order.lines.filter(type=OrderLineType.PRODUCT)): line.base_unit_price_value = Decimal(index + 1) line.save() order.save() response = client.get("/api/shuup/front/orders/{}/".format(order.pk)) response_data = json.loads(response.content.decode("utf-8")) assert response.status_code == status.HTTP_200_OK assert response_data["id"] == order.pk order.refresh_from_db() taxful_total_of_products = sum([line.price.value for line in order.lines.filter(type=OrderLineType.PRODUCT)]) taxless_total_of_products = sum([line.taxless_price.value for line in order.lines.filter(type=OrderLineType.PRODUCT)]) assert Decimal(response_data["taxful_total_price"]) == Decimal(order.taxful_total_price) assert Decimal(response_data["total_price_of_products"]) == Decimal(taxful_total_of_products) assert Decimal(response_data["taxful_total_price_of_products"]) == Decimal(taxful_total_of_products) # prices include tax assert Decimal(response_data["taxless_total_price_of_products"]) == Decimal(taxless_total_of_products) assert Decimal(response_data["taxful_total_discount"]) == Decimal(0) # add shipping OrderLine.objects.create( text="Shipping", order=order, type=OrderLineType.SHIPPING, ordering=order.lines.count(), base_unit_price_value=Decimal(5), quantity=1 ) # add discount OrderLine.objects.create( text="Discount", order=order, type=OrderLineType.DISCOUNT, ordering=order.lines.count(), discount_amount_value=Decimal(2), quantity=1 ) order.save() order.refresh_from_db() response = client.get("/api/shuup/front/orders/{}/".format(order.pk)) response_data = json.loads(response.content.decode("utf-8")) assert response.status_code == status.HTTP_200_OK assert response_data["id"] == order.pk total_of_products = sum([line.price.value for line in order.lines.filter(type=OrderLineType.PRODUCT)]) assert Decimal(response_data["taxful_total_price"]) == Decimal(order.taxful_total_price) assert Decimal(response_data["total_price_of_products"]) == Decimal(total_of_products) assert Decimal(response_data["taxful_total_discount"]) == Decimal(2) assert Decimal(sum_order_lines_price(order, "price", lambda line: line.type == OrderLineType.SHIPPING)) == Decimal(5) response = client.get("/api/shuup/front/orders/{}/".format(100)) assert response.status_code == 404 response = client.get("/api/shuup/front/orders/{}/".format(order2.pk)) assert response.status_code == 404
def mock_order(self, **kwargs): """ Create a random order """ shop = kwargs.pop("shop") return create_random_order(completion_probability=0.8, shop=shop)
def test_order_chart_works(): order = create_random_order(customer=create_random_person(), products=(get_default_product(), )) chart = OrderValueChartDashboardBlock("test", order.currency).get_chart() assert len(chart.series[0]) > 0
def random_order(): # These are prerequisites for random orders contact = create_random_person() product = get_default_product() return create_random_order(contact, [product])