def test_order_creator_account_manager(): company = create_random_company() shop = get_shop(identifier="random-shop", enabled=True) source = seed_source(create_random_user(), shop) source.customer = company source.add_line( type=OrderLineType.PRODUCT, product=get_default_product(), supplier=get_default_supplier(), quantity=1, base_unit_price=source.create_price(10), ) creator = OrderCreator() order = creator.create_order(source) assert order.account_manager is None # Company contact doesn't have account manager field person = create_random_person() person.account_manager = create_random_person() person.save() source = seed_source(create_random_user(), shop) source.customer = person source.add_line( type=OrderLineType.PRODUCT, product=get_default_product(), supplier=get_default_supplier(), quantity=1, base_unit_price=source.create_price(10), ) creator = OrderCreator() order = creator.create_order(source) assert order.account_manager is not None assert order.account_manager == person.account_manager with pytest.raises(ProtectedError): person.account_manager.delete()
def test_category_links_plugin_with_customer(rf, show_all_categories): """ Test plugin for categories that is visible for certain group """ shop = get_default_shop() group = get_default_customer_group() customer = create_random_person() customer.groups.add(group) customer.save() request = rf.get("/") request.shop = get_default_shop() apply_request_middleware(request) request.customer = customer category = get_default_category() category.status = CategoryStatus.VISIBLE category.visibility = CategoryVisibility.VISIBLE_TO_GROUPS category.visibility_groups.add(group) category.shops.add(shop) category.save() vars = {"request": request} context = get_jinja_context(**vars) plugin = CategoryLinksPlugin({"categories": [category.pk], "show_all_categories": show_all_categories}) assert category.is_visible(customer) assert category in plugin.get_context_data(context)["categories"] customer_without_groups = create_random_person() customer_without_groups.groups.clear() assert not category.is_visible(customer_without_groups) request.customer = customer_without_groups context = get_jinja_context(**vars) assert category not in plugin.get_context_data(context)["categories"]
def test_basket_contact_condition(rf): product_price_value, campaign_discount_value = 2, 1 request = get_request_for_contact_tests(rf) random_person = create_random_person() request.customer = random_person condition = ContactBasketCondition.objects.create() condition.contacts.add(random_person) basket, original_line_count, original_price = create_basket_and_campaign( request, [condition], product_price_value, campaign_discount_value) # random_person should get this campaign assert basket.customer == random_person assert_discounted_basket(basket, original_line_count, original_price, campaign_discount_value) another_random_person = create_random_person() basket.customer = another_random_person # another random person shouldn't assert_non_discounted_basket(basket, original_line_count, original_price) # Add another random person for the rule and see if he get's the discount condition.contacts.add(another_random_person) condition.save() assert_discounted_basket(basket, original_line_count, original_price, campaign_discount_value) assert basket.customer == another_random_person # Remove random person from rule and see the discount disappear condition.contacts.remove(random_person) condition.save() basket.customer = random_person assert_non_discounted_basket(basket, original_line_count, original_price) assert basket.customer == random_person
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 test_get_by_pk(admin_user): get_default_shop() for i in range(0, 10): create_random_person() contact = create_random_person() client = _get_client(admin_user) response = client.get("/api/wshop/contact/%s/" % contact.id) assert response.status_code == status.HTTP_200_OK contact_data = json.loads(response.content.decode("utf-8")) assert contact_data.get("id") == contact.id assert contact_data.get("name") == contact.name
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/wshop/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/wshop/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/wshop/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/wshop/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/wshop/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_contact_details_view_with_many_groups(rf, admin_user): get_default_shop() person = create_random_person() person.groups.add( ContactGroup.objects.create(name="Czz Group"), ContactGroup.objects.create(name="Azz Group"), ContactGroup.objects.create(name="Bzz Group"), ContactGroup.objects.language('fi').create(name="Dzz ryhmä"), ) # Group with name in two languages grp_e = ContactGroup.objects.language('en').create(name="Ezz Group") grp_e.set_current_language('fi') grp_e.name = "Ezz ryhmä" grp_e.save() person.groups.add(grp_e) request = apply_request_middleware(rf.get("/"), user=admin_user) with translation.override('en'): view_func = ContactDetailView.as_view() response = view_func(request, pk=person.pk) content = response.render().content.decode('utf-8') assert "Azz Group" in content assert "Bzz Group" in content assert "Czz Group" in content assert "Dzz ryhmä" in content, "no name in active language, still present" assert "Ezz Group" in content, "rendered with active language" positions = [content.index(x + "zz ") for x in 'ABCDE'] assert positions == sorted(positions), "Groups are sorted" assert response.status_code == 200
def test_filter_parameter_contact_groups(): customer_price = 10.3 anonymous_price = 14.6 def get_price_info_mock(context, product, quantity=1): if context.customer.get_default_group() == AnonymousContact( ).get_default_group(): price = context.shop.create_price(anonymous_price) else: price = context.shop.create_price(customer_price) return PriceInfo(quantity * price, quantity * price, quantity) with patch.object(DummyPricingModule, 'get_price_info', side_effect=get_price_info_mock): (engine, context) = _get_template_engine_and_context(product_sku="123") # test with anonymous context['request'].customer = AnonymousContact() context['request'].person = context['request'].customer result = engine.from_string("{{ prod|price(quantity=2) }}") assert result.render(context) == "$%0.2f" % (anonymous_price * 2) # Get fresh content. I guess the prices shouldn't change between request. (engine, context) = _get_template_engine_and_context(product_sku="1234") # test with customer context['request'].customer = create_random_person() context['request'].person = context['request'].customer result = engine.from_string("{{ prod|price(quantity=2) }}") assert result.render(context) == "$%0.2f" % (customer_price * 2)
def test_parallel_baskets(rf): request = get_request_with_basket() shop = get_default_shop() customer = create_random_person() request = rf.get("/") request.shop = shop apply_request_middleware(request) request.customer = customer basket_one = get_basket(request, basket_name="basket_one") basket_two = get_basket(request, basket_name="basket_two") product_one = get_default_product() product_two = get_default_product() product_two.sku = "derpy-hooves" sales_unit = SalesUnit.objects.create(identifier="test-sales-partial", decimals=2, name="Partial unit") product_two.sales_unit = sales_unit # Set the sales unit for the product product_two.save() basket_commands.handle_add(request, basket_one, product_id=product_one.pk, quantity=1) basket_commands.handle_add(request, basket_two, product_id=product_two.pk, quantity=3.5) assert basket_one.product_count == 1 assert basket_two.product_count == 3.5
def test_contact_module_search_multishop(rf): with override_settings(WSHOP_MANAGE_CONTACTS_PER_SHOP=True, WSHOP_ENABLE_MULTIPLE_SHOPS=True): staff_user = create_random_user(is_staff=True) shop1 = get_shop(identifier="shop-1", enabled=True) shop2 = get_shop(identifier="shop-2", enabled=True) shop1.staff_members.add(staff_user) shop2.staff_members.add(staff_user) cm = ContactModule() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) contact.shops.add(shop2) request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop2) # find the shop assert not empty_iterable( cm.get_search_results(request, query=contact.email)) assert not empty_iterable( cm.get_search_results(request, query=contact.first_name)) # no shop found request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop1) assert empty_iterable( cm.get_search_results(request, query=contact.email))
def test_sales_ranges_update_after_range_update(): shop = get_default_shop() supplier = get_default_supplier() person = create_random_person() company = create_random_company() create_fully_paid_order(shop, person, supplier, "sku1", 50) create_fully_paid_order(shop, company, supplier, "sku2", 100) assert get_total_sales(shop, person) == 50 assert get_total_sales(shop, company) == 100 sales_range = create_sales_range("gold", shop, 10, 90) assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all() sales_range.max_value = None sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group in company.groups.all() # Make sure customers is actually removed when range changes sales_range.max_value = 60 sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all() # Inactive ranges shouldn't update group members sales_range.min_value = None sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all()
def test_sales_between_ranges(): shop = get_default_shop() supplier = get_default_supplier() person = create_random_person() initial_group_count = person.groups.count() sales_ranges = [("wood", 15, 0), ("silver", 0, 50), ("diamond", 100, None)] for identifier, min, max in sales_ranges: create_sales_range(identifier, shop, min, max) payment = create_fully_paid_order(shop, person, supplier, "sku1", 10) assert get_total_sales(shop, person) == 10 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([ group for group in person.groups.all() if group.identifier == "silver" ]) assert not bool( [group for group in person.groups.all() if group.identifier == "wood"]) payment = create_fully_paid_order(shop, person, supplier, "sku2", 50) assert get_total_sales(shop, person) == 60 update_customers_groups(Payment, payment) assert person.groups.count() == initial_group_count assert not bool([ group for group in person.groups.all() if group.identifier in ["silver", "gold", "diamond"] ]) payment = create_fully_paid_order(shop, person, supplier, "sku3", 200) assert get_total_sales(shop, person) == 260 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([ group for group in person.groups.all() if group.identifier == "diamond" ])
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_product_pricing_cache(admin_user): shop = get_default_shop() group = create_random_contact_group() group2 = create_random_contact_group() product = create_product("Just-A-Product", shop, default_price=200) CgpPrice.objects.create(product=product, shop=shop, group=group, price_value=175) CgpPrice.objects.create(product=product, shop=shop, group=group2, price_value=150) client = _get_client(admin_user) response = client.get("/api/wshop/front/shop_products/") products_data = json.loads(response.content.decode("utf-8")) assert products_data[0]["price"] == 200 user = get_user_model().objects.first() user.pk = None user.username = "******" user.save() customer = create_random_person() customer.groups.add(group) customer.user = user customer.save() client = _get_client(user) response = client.get("/api/wshop/front/shop_products/") products_data = json.loads(response.content.decode("utf-8")) assert products_data[0]["price"] == 175 client = _get_client(admin_user) response = client.get("/api/wshop/front/shop_products/") products_data = json.loads(response.content.decode("utf-8")) assert products_data[0]["price"] == 200
def test_set_non_shop_member_customer(rf): """ Set some customer to the basket that is not member of the shop """ with override_settings(**CORE_BASKET_SETTINGS): shop = factories.get_shop(False) assert shop != factories.get_default_shop() user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) assert basket.shop == factories.get_default_shop() person = factories.create_random_person() person.shops.add(shop) company = factories.create_random_company() company.shops.add(shop) for customer in [person, company]: with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, customer) assert exc.value.code == "invalid_customer_shop" assert basket.customer == get_person_contact(user)
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_campaign_with_non_active_coupon(rf): initial_status = get_initial_order_status() request, shop, group = initialize_test(rf, include_tax=False) order = _get_order_with_coupon(request, initial_status) coupon = order.coupon_usages.first().coupon coupon.active = False coupon.save() modifier = UserFactory() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) assert order.customer != contact state = _get_frontend_order_state(shop, contact) assert order.shop.id == state["shop"]["selected"]["id"] request = get_frontend_request_for_command(state, "finalize", modifier) response = OrderEditView.as_view()(request, pk=order.pk) assert_contains(response, "orderIdentifier") data = json.loads(response.content.decode("utf8")) edited_order = Order.objects.get(pk=order.pk) assert edited_order.identifier == data[ "orderIdentifier"] == order.identifier assert edited_order.pk == order.pk assert edited_order.lines.count() == 3 assert OrderLineType.DISCOUNT not in [ l.type for l in edited_order.lines.all() ] assert edited_order.coupon_usages.count() == 0
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_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_mass_edit_orders2(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": OrderConfirmationPdfAction().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 if weasyprint: assert response[ 'Content-Disposition'] == 'attachment; filename=order_%s_confirmation.pdf' % order.pk else: assert response["content-type"] == "application/json"
def test_contact_company_list_multishop(rf): with override_settings(WSHOP_MANAGE_CONTACTS_PER_SHOP=True, WSHOP_ENABLE_MULTIPLE_SHOPS=True): staff_user = create_random_user(is_staff=True) shop1 = get_shop(identifier="shop-1", enabled=True) shop2 = get_shop(identifier="shop-2", enabled=True) shop1.staff_members.add(staff_user) shop2.staff_members.add(staff_user) # only available in shop2 contact = create_random_person(locale="en_US", minimum_name_comp_len=5) contact.shops.add(shop2) # only available in shop1 company = create_random_company() company.shops.add(shop1) view = ContactListView() request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop1) view.request = request assert company in view.get_queryset() assert contact not in view.get_queryset() request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop2) view.request = request assert contact in view.get_queryset() assert company not in view.get_queryset()
def test_get_by_email(admin_user): get_default_shop() for i in range(0, 10): create_random_person() contact = create_random_person() client = _get_client(admin_user) response = client.get("/api/wshop/contact/", data={"email": contact.email}) assert response.status_code == status.HTTP_200_OK contact_data = json.loads(response.content.decode("utf-8")) assert Contact.objects.filter( email=contact.email).count() == len(contact_data) assert contact_data[0].get("id") == contact.id assert contact_data[0].get("email") == contact.email assert contact_data[0].get("name") == contact.name
def test_order_creator_source_data(rf, admin_user): get_initial_order_status() # Needed for the API contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = get_frontend_request_for_command( get_frontend_order_state(contact), "source_data", admin_user) response = OrderEditView.as_view()(request) data = json.loads(response.content.decode("utf8")) assert len(data.get("orderLines")) == 5
def test_mass_edit_contacts2(rf, admin_user): activate("en") shop = get_default_shop() contact1 = create_random_person() contact2 = create_random_person() contact_group = ContactGroup.objects.create(name="test") data = {"contact_group": contact_group.pk} request = apply_request_middleware(rf.post("/", data=data), user=admin_user) request.session["mass_action_ids"] = [contact1.pk, contact2.pk] view = ContactGroupMassEditView.as_view() response = view(request=request) assert response.status_code == 302 contact_group = ContactGroup.objects.first() for contact in Contact.objects.all(): assert contact in contact_group.members.all()
def test_order_creator_view_for_customer(rf, admin_user): get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = apply_request_middleware(rf.get("/", {"contact_id": contact.id}), user=admin_user) response = OrderEditView.as_view()(request) assert_contains(response, "customerData") # in the config assert_contains(response, "isCompany") # in the config
def test_contact_detail_has_custom_toolbar_button(rf, admin_user): get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = apply_request_middleware(rf.get("/"), user=admin_user) view_func = ContactDetailView.as_view() response = view_func(request, pk=contact.pk) content = force_text(response.render().content) assert "#mocktoolbarbutton" in content, 'custom toolbar button not found on detail page'
def test_get_by_contact_group(admin_user): get_default_shop() for i in range(0, 10): create_random_person() contact = create_random_person() group = get_default_customer_group() group.members.add(contact) client = _get_client(admin_user) response = client.get("/api/wshop/contact/", data={"groups": group.id}) assert response.status_code == status.HTTP_200_OK contact_data = json.loads(response.content.decode("utf-8")) assert group.members.count() == len(contact_data) assert contact_data[0].get("id") == contact.id assert contact_data[0].get("email") == contact.email assert contact_data[0].get("name") == contact.name
def test_without_groups(admin_user): payment_method = get_default_payment_method() _assign_component_for_service(payment_method, []) person = create_random_person() person.user = admin_user person.save() source = _get_source_for_contact(admin_user, payment_method) assert source.customer == person _test_service_availability(source, payment_method, False)
def test_mass_edit_contacts(rf, admin_user): shop = get_default_shop() contact1 = create_random_person() contact2 = create_random_person() contact1.gender = Gender.FEMALE contact1.save() contact2.gender = Gender.FEMALE contact2.save() contact_ids = [contact1.pk, contact2.pk] request = apply_request_middleware(rf.post( "/", data={"gender": Gender.MALE.value}), user=admin_user) request.session["mass_action_ids"] = contact_ids view = ContactMassEditView.as_view() response = view(request=request) assert response.status_code == 302 for contact in Contact.objects.filter(id__in=contact_ids): assert contact.gender == Gender.MALE
def test_set_different_customer(rf): """ Set some customer to the basket that is not the request one """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) person1 = factories.create_random_person() with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, person1) assert exc.value.code == "no_permission" assert basket.customer == get_person_contact(user) # with superuser person2 = factories.create_random_person() superuser = factories.create_random_user(is_superuser=True) request = apply_request_middleware(rf.get("/"), user=superuser) assert basket_commands.handle_set_customer(request, basket, person2)["ok"] is True assert basket.customer == person2 assert basket.orderer == person2 # with staff user not member of the shop person3 = factories.create_random_person() staff = factories.create_random_user(is_staff=True) request = apply_request_middleware(rf.get("/"), user=staff) with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, person3) assert exc.value.code == "no_permission" assert basket.customer == person2 assert basket.orderer == person2 # with staff user member of the shop person4 = factories.create_random_person() staff_member = factories.create_random_user(is_staff=True) basket.shop.staff_members.add(staff_member) request = apply_request_middleware(rf.get("/"), user=staff_member) assert basket_commands.handle_set_customer(request, basket, person4)["ok"] is True assert basket.customer == person4 assert basket.orderer == person4