Esempio n. 1
0
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"
Esempio n. 2
0
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()
Esempio n. 4
0
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')))
Esempio n. 5
0
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"]
Esempio n. 6
0
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"]
Esempio n. 7
0
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()
Esempio n. 8
0
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_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"
Esempio n. 10
0
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()
Esempio n. 11
0
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 . . .
Esempio n. 12
0
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)
Esempio n. 13
0
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
Esempio n. 14
0
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 . . .
Esempio n. 15
0
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
Esempio n. 17
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
Esempio n. 18
0
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
Esempio n. 19
0
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
Esempio n. 21
0
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
Esempio n. 22
0
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 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())
Esempio n. 24
0
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')))
Esempio n. 25
0
    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
Esempio n. 26
0
    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
Esempio n. 27
0
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()
    )
Esempio n. 28
0
 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
Esempio n. 29
0
    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
Esempio n. 30
0
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
Esempio n. 31
0
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
Esempio n. 32
0
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
Esempio n. 33
0
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
Esempio n. 34
0
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()
Esempio n. 35
0
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()
Esempio n. 36
0
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
Esempio n. 37
0
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
Esempio n. 38
0
    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)
Esempio n. 39
0
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
Esempio n. 40
0
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"))
Esempio n. 41
0
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_")
Esempio n. 42
0
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)
Esempio n. 43
0
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_")
Esempio n. 44
0
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
Esempio n. 47
0
 def mock_order(self):
     """ Create a random order """
     return create_random_order(completion_probability=0.8)
Esempio n. 48
0
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
Esempio n. 49
0
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
Esempio n. 50
0
    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 = []
Esempio n. 51
0
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
Esempio n. 52
0
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
Esempio n. 53
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
Esempio n. 54
0
 def mock_order(self, **kwargs):
     """ Create a random order """
     shop = kwargs.pop("shop")
     return create_random_order(completion_probability=0.8, shop=shop)
Esempio n. 55
0
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
Esempio n. 56
0
def random_order():
    # These are prerequisites for random orders
    contact = create_random_person()
    product = get_default_product()
    return create_random_order(contact, [product])