def test_basic_order_flow_registered(regular_user): cache.clear() create_default_order_statuses() n_orders_pre = Order.objects.count() populate_if_required() get_test_script("test script", "order_received") # paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) template_data = STEP_DATA[0]["actions"][0]["template_data"] LANG_CODE = {"en": "US", "fi": "FI"} for lang in ["en", "fi"]: n_outbox_pre = len(mail.outbox) contact = get_person_contact(regular_user) contact.language = lang contact.save() c = SmartClient() c.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) product_ids = _populate_client_basket(c) addresses_soup = c.soup(addresses_path) address = get_address(country=LANG_CODE[lang]) inputs = fill_address_inputs(addresses_soup, address) response = c.post(addresses_path, data=inputs) assert response.status_code == 302 # Should redirect forth methods_soup = c.soup(methods_path) assert c.post(methods_path, data=extract_form_fields( methods_soup)).status_code == 302 # Should redirect forth confirm_soup = c.soup(confirm_path) Product.objects.get(pk=product_ids[0]).soft_delete() assert ( c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 ) # user needs to reconfirm data = extract_form_fields(confirm_soup) data["accept_terms"] = True data["product_ids"] = ",".join(product_ids[1:]) assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth n_orders_post = Order.objects.count() assert n_orders_post > n_orders_pre, "order was created" assert len(mail.outbox) == n_outbox_pre + 1, "Sending email failed" latest_mail = mail.outbox[-1] # mail is always sent in fallback language since user is not registered assert latest_mail.subject == template_data[lang][ "subject"], "Subject doesn't match" assert latest_mail.body == template_data[lang][ "body"], "Body doesn't match"
def test_basic_order_flow_registered(regular_user): cache.clear() create_default_order_statuses() n_orders_pre = Order.objects.count() populate_if_required() get_test_script("test script", "order_received") # paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) template_data = STEP_DATA[0]["actions"][0]["template_data"] LANG_CODE = { "en": "US", "fi": "FI" } for lang in ["en", "fi"]: n_outbox_pre = len(mail.outbox) contact = get_person_contact(regular_user) contact.language = lang contact.save() c = SmartClient() c.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) product_ids = _populate_client_basket(c) addresses_soup = c.soup(addresses_path) address = get_address(country=LANG_CODE[lang]) inputs = fill_address_inputs(addresses_soup, address) response = c.post(addresses_path, data=inputs) assert response.status_code == 302 # Should redirect forth methods_soup = c.soup(methods_path) assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth confirm_soup = c.soup(confirm_path) Product.objects.get(pk=product_ids[0]).soft_delete() assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm data = extract_form_fields(confirm_soup) data['product_ids'] = ','.join(product_ids[1:]) assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth n_orders_post = Order.objects.count() assert n_orders_post > n_orders_pre, "order was created" assert (len(mail.outbox) == n_outbox_pre + 1), "Sending email failed" latest_mail = mail.outbox[-1] # mail is always sent in fallback language since user is not registered assert latest_mail.subject == template_data[lang]["subject"], "Subject doesn't match" assert latest_mail.body == template_data[lang]["body"], "Body doesn't match"
def _configure_basket(client): """ * Adds a product * Sets a default shipping method * Sets a CieloPaymentProcessor payment method * Sets user address """ default_product = get_default_product() sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop()) sp.default_price = get_default_shop().create_price(PRODUCT_PRICE) sp.save() basket_path = reverse("shuup:basket") client.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": PRODUCT_QTNTY, "supplier": get_default_supplier().pk }) # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, CieloPaymentProcessor) payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) # Phase: Addresses addresses_soup = client.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) client.post(addresses_path, data=inputs) # Phase: Methods client.post( reverse("shuup:checkout", kwargs={"phase": "methods"}), data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } )
def _configure_basket(client): """ * Adds a product * Sets a default shipping method * Sets a CieloPaymentProcessor payment method * Sets user address """ default_product = get_default_product() sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop()) sp.default_price = get_default_shop().create_price(PRODUCT_PRICE) sp.save() basket_path = reverse("shuup:basket") client.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": PRODUCT_QTNTY, "supplier": get_default_supplier().pk }) # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, CieloPaymentProcessor) payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) # Phase: Addresses addresses_soup = client.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) client.post(addresses_path, data=inputs) # Phase: Methods client.post(reverse("shuup:checkout", kwargs={"phase": "methods"}), data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk })
def create_success_order_with_boleto(): # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, BoletoPaymentProcessor) choices = processor.get_service_choices() assert len(choices) == 1 payment_method = processor.create_service( BankService.CECRED.value, identifier="cecred", shop=get_default_shop(), name="boleto cecred", enabled=True, tax_class=get_default_tax_class()) # Configura de acordo behavior_component = payment_method.behavior_components.first() behavior_component.local_pagamento = "a simple test" behavior_component.cedente = "a simple user" behavior_component.prazo_vencimento = 4 behavior_component.instrucoes = ["line1", "line2"] behavior_component.especie_doc = DocumentType.DM behavior_component.layout = 'v06' behavior_component.agencia = '123431' behavior_component.conta = '6427364732' behavior_component.convenio = '123456' behavior_component.carteira = '12' behavior_component.save() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse("shuup:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) order_complete_path = reverse("shuup:order_complete", kwargs={ "pk": order.pk, "key": order.key }) c.get(process_payment_path) c.get(process_payment_return_path) c.get(order_complete_path) order.refresh_from_db() return order
def test_refresh_transaction_view(rf, admin_user): initialize() c = SmartClient() default_product = get_default_product() ORDER_TOTAL = PRODUCT_PRICE * 1 basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) transaction_path = reverse("shuup:cielo_make_transaction") # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post( methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } ) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(numero=1, valor=decimal_to_int_cents(ORDER_TOTAL), produto=CieloProduct.Credit, bandeira=CieloCardBrand.Visa, parcelas=CC_VISA_1X_INFO['installments'], tid=tid) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): c.soup(payment_path) c.post(transaction_path, CC_VISA_1X_INFO) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key}) c.get(process_payment_path) c.get(process_payment_return_path) order.refresh_from_db() cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order) # transacao nao capturada assert cielo_transaction.tid == tid assert cielo_transaction.total_captured.value == Decimal() view = load("shuup_cielo.admin.views.RefreshTransactionView").as_view() request = apply_request_middleware(rf.post("/"), user=admin_user) # request sem parametro - bad request response = view(request) assert response.status_code == 500 transacao = get_captured_transaction(transacao) with patch.object(CieloRequest, 'consultar', return_value=transacao): request = apply_request_middleware(rf.post("/", {"id":cielo_transaction.pk}), user=admin_user) response = view(request) assert response.status_code == 200 cielo_transaction.refresh_from_db() assert cielo_transaction.total_captured_value == order.taxful_total_price_value
def test_refresh_transaction_view(rf, admin_user): initialize() c = SmartClient() default_product = get_default_product() ORDER_TOTAL = PRODUCT_PRICE * 1 basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) transaction_path = reverse("shuup:cielo_make_transaction") # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction( numero=1, valor=decimal_to_int_cents(ORDER_TOTAL), produto=CieloProduct.Credit, bandeira=CieloCardBrand.Visa, parcelas=CC_VISA_1X_INFO['installments'], tid=tid) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): c.soup(payment_path) c.post(transaction_path, CC_VISA_1X_INFO) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse( "shuup:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) c.get(process_payment_path) c.get(process_payment_return_path) order.refresh_from_db() cielo_transaction = CieloTransaction.objects.get( order_transaction__order=order) # transacao nao capturada assert cielo_transaction.tid == tid assert cielo_transaction.total_captured.value == Decimal() view = load("shuup_cielo.admin.views.RefreshTransactionView").as_view() request = apply_request_middleware(rf.post("/"), user=admin_user) # request sem parametro - bad request response = view(request) assert response.status_code == 500 transacao = get_captured_transaction(transacao) with patch.object(CieloRequest, 'consultar', return_value=transacao): request = apply_request_middleware(rf.post( "/", {"id": cielo_transaction.pk}), user=admin_user) response = view(request) assert response.status_code == 200 cielo_transaction.refresh_from_db() assert cielo_transaction.total_captured_value == order.taxful_total_price_value
def test_views(rf): initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( PagSeguroPaymentMethod.ONLINE_DEBIT.value, identifier="pagseguro_debit", shop=get_default_shop(), name="debit", enabled=True, tax_class=get_default_tax_class()) addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) c.soup(payment_path) c.post( payment_path, { "paymentMethod": PagSeguroPaymentMethodIdentifier.Debito, "bankOption": "{0}".format(PagSeguroPaymentMethodCode.DebitoOnlineBB.value), "senderHash": "J7E98Y37WEIRUHDIAI9U8RYE7UQE" }) transaction_code = "38490248UEHBU90-2342-324502221-442" confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() payment = PagSeguroPayment.objects.create( order=order, code=transaction_code, data={"transaction": { "status": "1" }}) payment.save() order.payment_data['pagseguro']['code'] = payment.code order.save() # Verifica: pagseguro_payment_return response = c.get(reverse("shuup:pagseguro_payment_return")) assert response.status_code == 302 assert reverse("shuup:checkout", kwargs={"phase": "payment"}) in response.url notify_path = reverse("shuup:pagseguro_notification") # Erro: notificationCode nao informado response = c.post(notify_path) assert response.status_code == 200 assert len(response.content.decode("utf-8")) == 0 assert response[ "Access-Control-Allow-Origin"] == 'https://sandbox.pagseguro.uol.com.br' # Sucesso 1 transaction_info = xmltodict.parse(""" <?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?> <transaction> <status>2</status> <code>{0}</code> </transaction> """.format(transaction_code).strip()) # altera retorno do get_notification_info with patch.object(PagSeguro, 'get_notification_info', return_value=transaction_info): response = c.post(notify_path, {"notificationCode": "it-does-not-mattter"}) assert response.status_code == 200 assert response[ "Access-Control-Allow-Origin"] == 'https://sandbox.pagseguro.uol.com.br' payment.refresh_from_db() order.refresh_from_db() assert payment.data['transaction']['status'] == "2" assert payment.data['transaction']['code'] == transaction_code assert order.payment_status == PaymentStatus.NOT_PAID # Sucesso 2 - PAGO, emite notificacao e bota o pedido como pago transaction_info = xmltodict.parse(""" <?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?> <transaction> <status>3</status> <code>{0}</code> </transaction> """.format(transaction_code).strip()) with patch.object(PagSeguro, 'get_notification_info', return_value=transaction_info): response = c.post(notify_path, {"notificationCode": "it-does-not-mattter"}) assert response.status_code == 200 payment.refresh_from_db() order.refresh_from_db() assert payment.data['transaction']['status'] == "3" assert order.payment_status == PaymentStatus.FULLY_PAID # volta o pedido ao estado de não pago order.payment_status = PaymentStatus.NOT_PAID order.save() # Sucesso 3 - CANCELADO, emite notificacao e bota o pedido como cancelado transaction_info = xmltodict.parse(""" <?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?> <transaction> <status>7</status> <code>{0}</code> </transaction> """.format(transaction_code).strip()) with patch.object(PagSeguro, 'get_notification_info', return_value=transaction_info): response = c.post(notify_path, {"notificationCode": "it-does-not-mattter"}) assert response.status_code == 200 payment.refresh_from_db() order.refresh_from_db() assert payment.data['transaction']['status'] == "7" assert order.status.role == OrderStatusRole.CANCELED
def test_boleto_cecred_success(): """ Usuário faz a compra e seleciona boleto como forma de pagamento (3 vezes seguidas) Boleto CECRED configurado """ initialize() # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, BoletoPaymentProcessor) choices = processor.get_service_choices() assert len(choices) == 1 payment_method = processor.create_service( BankService.CECRED.value, identifier="cecred", shop=get_default_shop(), name="boleto cecred", enabled=True, tax_class=get_default_tax_class()) # Configura de acordo behavior_component = payment_method.behavior_components.first() behavior_component.local_pagamento = "a simple test" behavior_component.cedente = "a simple user" behavior_component.prazo_vencimento = 4 behavior_component.instrucoes = ["line1", "line2"] behavior_component.especie_doc = DocumentType.DM behavior_component.layout = 'v06' behavior_component.agencia = '123431' behavior_component.conta = '6427364732' behavior_component.convenio = '123456' behavior_component.carteira = '12' behavior_component.save() for ix in range(3): c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == ix response = c.post( methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } ) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 200 # Phase: Confirm assert Order.objects.count() == ix confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" assert Order.objects.count() == ix+1 order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_status == PaymentStatus.NOT_PAID process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key}) order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key}) assert response.url.endswith(process_payment_path), ("Confirm should have redirected to payment page") response = c.get(process_payment_path) assert response.status_code == 302, "Payment page should redirect forth" assert response.url.endswith(process_payment_return_path) response = c.get(process_payment_return_path) assert response.status_code == 302, "Payment return should redirect forth" assert response.url.endswith(order_complete_path) order.refresh_from_db() assert order.payment_status == PaymentStatus.NOT_PAID from python_boleto.cecred import CecredBoleto bcecred = CecredBoleto(**order.boleto.info) bcecred.validate() assert len(order.boleto.html) > 0 # "visualiza o boleto" view_boleto_path = reverse("shuup:view_boleto", kwargs={"order_pk": order.pk, "order_key": order.key}) response = c.get(view_boleto_path) assert HttpResponse(order.boleto.html).content == response.content
def test_debit_auto_capture_with_auth(): """ Caso: - Transação com Cartão de Débito - Auto captura HABILITADO - Com URL para autenticação - 1 parcela """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, CieloPaymentProcessor) # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == 0 response = c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 302, "Confirm should first redirect forth" assert response.url.endswith(payment_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(1, decimal_to_int_cents(ORDER_TOTAL), CieloProduct.InstallmentCredit, CieloCardBrand.Visa, CC_VISA_4X_INFO['installments'], tid, return_url=None) transacao = get_approved_transaction(transacao) transacao = get_captured_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): with patch.object(CieloRequest, 'capturar', return_value=transacao): # Phase: pay response = c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) assert response.status_code == 200 json_content = json.loads(response.content.decode("utf-8")) assert json_content['redirect_url'].endswith( reverse("shuup:cielo_transaction_return", kwargs={"cielo_order_pk": 1})) cielo_transaction = CieloTransaction.objects.get(tid=tid) assert cielo_transaction.cc_brand == CC_VISA_4X_INFO[ 'cc_brand'] assert cielo_transaction.cc_holder == CC_VISA_4X_INFO[ 'cc_holder'] assert cielo_transaction.installments == CC_VISA_4X_INFO[ 'installments'] assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit assert abs(cielo_transaction.total_value - ORDER_TOTAL) < 0.01 assert cielo_transaction.status.value == transacao.status response = c.post(json_content['redirect_url']) assert response.status_code == 302 assert response.url.endswith(confirm_path) # Phase: Confirm assert Order.objects.count() == 0 confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" order = Order.objects.filter( payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse( "shuup:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) order_complete_path = reverse("shuup:order_complete", kwargs={ "pk": order.pk, "key": order.key }) response = c.get(process_payment_path) assert response.status_code == 302, "Payment page should redirect forth" assert response.url.endswith(process_payment_return_path) # Check payment return response = c.get(process_payment_return_path) assert response.status_code == 302, "Payment return should redirect forth" assert response.url.endswith(order_complete_path) cielo_transaction = CieloTransaction.objects.get( order_transaction__order=order, tid=tid) assert cielo_transaction.status == CieloTransactionStatus.Captured assert cielo_transaction.authorization_nsu == str( transacao.autorizacao.nsu) assert cielo_transaction.authorization_lr == str( transacao.autorizacao.lr) assert cielo_transaction.authorization_date == iso8601.parse_date( transacao.autorizacao.data_hora) assert cielo_transaction.authentication_eci == transacao.autenticacao.eci assert cielo_transaction.authentication_date == iso8601.parse_date( transacao.autenticacao.data_hora) assert cielo_transaction.total_captured_value == ORDER_TOTAL assert cielo_transaction.total_reversed_value == Decimal() order.refresh_from_db() assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY) assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY) assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_fail(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas - dados do pagamento nao existem """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(1, decimal_to_int_cents(ORDER_TOTAL), CieloProduct.InstallmentCredit, CieloCardBrand.Visa, CC_VISA_4X_INFO['installments'], tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) json_content = json.loads(response.content.decode("utf-8")) response = c.post(json_content['redirect_url']) confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) # FORCE CLEAR ORDER PAYMENT DATA order.payment_data = {} order.save() response = c.get(process_payment_path) order.refresh_from_db() assert order.status == OrderStatus.objects.get_default_canceled()
def test_checkout(admin_user): get_default_shop() set_current_theme('shuup.themes.classic_gray') create_default_order_statuses() populate_if_required() create_test_data() default_product = get_default_product() sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop()) sp.default_price = get_default_shop().create_price(Decimal(10.0)) sp.save() service = get_custom_carrier_service() component = SpecificShippingTableBehaviorComponent.objects.create( table=ShippingTable.objects.get(identifier='table-1')) service.behavior_components.add(component) c = SmartClient() basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 shipping_method = service payment_method = get_payment_method(name="neat", price=4) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) inputs['shipping-postal_code'] = "89060201" inputs['shipping-country'] = "BR" response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == 0 response = c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 200 # Phase: Confirm assert Order.objects.count() == 0 confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" assert Order.objects.count() == 1 order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_status == PaymentStatus.NOT_PAID
def test_payment_refresh(): """ Testa pagamentos """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( PagSeguroPaymentMethod.ONLINE_DEBIT.value, identifier="pagseguro_debit", shop=get_default_shop(), name="debit", enabled=True, tax_class=get_default_tax_class()) service_choices = processor.get_service_choices() assert len(service_choices) == 2 assert service_choices[0].identifier == PagSeguroPaymentMethod.BOLETO.value assert service_choices[ 1].identifier == PagSeguroPaymentMethod.ONLINE_DEBIT.value addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) c.soup(payment_path) c.post( payment_path, { "paymentMethod": PagSeguroPaymentMethodIdentifier.Debito, "bankOption": "{0}".format(PagSeguroPaymentMethodCode.DebitoOnlineBB.value), "senderHash": "J7E98Y37WEIRUHDIAI9U8RYE7UQE" }) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse("shuup:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) order_complete_path = reverse("shuup:order_complete", kwargs={ "pk": order.pk, "key": order.key }) c.get(process_payment_path) c.get(process_payment_return_path) c.get(order_complete_path) # testa o refresh do pagamento payment = PagSeguroPayment.objects.get(order=order) transaction_info = xmltodict.parse(""" <?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?> <transaction> <status>2</status> </transaction> """.strip()) # altera o estado da transacao with patch.object(PagSeguro, 'get_transaction_info', return_value=transaction_info): assert payment.data['transaction']['status'] == "3" payment.refresh() assert payment.data['transaction']['status'] == "2" # format string "{0}".format(payment)
def test_pagseguro(): initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( PagSeguroPaymentMethod.ONLINE_DEBIT.value, identifier="pagseguro_debit", shop=get_default_shop(), name="debit", enabled=True, tax_class=get_default_tax_class()) addr = MutableAddress.from_data( dict( name=u"Dog Hello", suffix=", Esq.", postal_code="89999-999", street="Woof Ave.", city="Dog Fort", country="GB", phone="47 98821-2231", )) patch("shuup.testing.factories.get_address", new_callable=lambda: addr) addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) c.soup(payment_path) c.post( payment_path, { "paymentMethod": PagSeguroPaymentMethodIdentifier.Debito, "bankOption": "{0}".format(PagSeguroPaymentMethodCode.DebitoOnlineBB.value), "senderHash": "J7E98Y37WEIRUHDIAI9U8RYE7UQE" }) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() USER_MODEL = get_user_model() order.phone = "47 98821-2231" order.creator = get_user_model().objects.create_user( **{ USER_MODEL.USERNAME_FIELD: "*****@*****.**", "password": "******" }) order.save() pagseguro = PagSeguro.create_from_config(get_pagseguro_config()) # unpatch methods patch.stopall() # Test: get_session_id - SUCCESS session_xml_fake = """<session><id>WOEIFJE9IUREI29RU8</id></session>""" response = Mock() response.status_code = 200 response.content = session_xml_fake with patch.object(requests, 'post', return_value=response): session_id = xmltodict.parse(session_xml_fake)['session']['id'] assert pagseguro.get_session_id() == session_id # Test: get_session_id - EXCEPTION response = Mock() response.status_code = 500 response.content = ERROR_XML with patch.object(requests, 'post', return_value=response): with pytest.raises(PagSeguroException) as exc: pagseguro.get_session_id() assert exc.value.status_code == 500 assert exc.value.error == ERROR_XML # Test: get_notification_info - SUCCESS transaction_xml_fake = """<transaction><date>WOEIFJE9IUREI29RU8</date></transaction>""" response = Mock() response.status_code = 200 response.content = transaction_xml_fake with patch.object(requests, 'get', return_value=response): assert pagseguro.get_notification_info("XXXX") == xmltodict.parse( transaction_xml_fake) # Test: get_notification_info - EXCEPTION response = Mock() response.status_code = 500 response.content = ERROR_XML with patch.object(requests, 'get', return_value=response): with pytest.raises(PagSeguroException) as exc: pagseguro.get_notification_info("ZZZZ") assert exc.value.status_code == 500 assert exc.value.error == ERROR_XML # Test: get_transaction_info - SUCCESS transaction_xml_fake = """<transaction><date>WOEIFJE9IUREI29RU8</date></transaction>""" response = Mock() response.status_code = 200 response.content = transaction_xml_fake with patch.object(requests, 'get', return_value=response): assert pagseguro.get_transaction_info("XXXX") == xmltodict.parse( transaction_xml_fake) # Test: get_transaction_info - EXCEPTION response = Mock() response.status_code = 500 response.content = ERROR_XML with patch.object(requests, 'get', return_value=response): with pytest.raises(PagSeguroException) as exc: pagseguro.get_transaction_info("ZZZZ") assert exc.value.status_code == 500 assert exc.value.error == ERROR_XML # Test: pay - SUCCESS response = Mock() response.status_code = 200 response.content = TRANSACTION_XML with patch.object(requests, 'post', return_value=response): parsed_xml = xmltodict.parse(TRANSACTION_XML) result = pagseguro.pay(payment_method, order) assert isinstance(result, PagSeguroPaymentResult) assert result.error is False assert result._data == parsed_xml assert result.code == parsed_xml['transaction']['code'] assert result.payment_link == parsed_xml['transaction']['paymentLink'] # Test: pay - ERROR response = Mock() response.status_code = 400 response.content = ERROR_XML with patch.object(requests, 'post', return_value=response): parsed_xml = xmltodict.parse(ERROR_XML) result = pagseguro.pay(payment_method, order) assert isinstance(result, PagSeguroPaymentResult) assert result.error is True assert result._data == parsed_xml assert result.errors == parsed_xml['errors'] # Test: pay - EXCEPTION response = Mock() response.status_code = 500 response.content = "A BIG MISTAKE" with patch.object(requests, 'post', return_value=response): with pytest.raises(PagSeguroException) as exc: pagseguro.pay(payment_method, order) assert exc.value.status_code == 500 assert exc.value.error == "A BIG MISTAKE" def get_only_nums(value): return "".join([c for c in value if c.isdigit()]) # Test: _get_payment_xml with CPF order.creator.pf_person = PFPerson() payment_xml = xmltodict.parse( pagseguro._get_payment_xml(payment_method, order)) assert payment_xml['payment']['currency'] == 'BRL' assert payment_xml['payment'][ 'method'] == PagSeguroPaymentMethodIdentifier.Debito assert payment_xml['payment']['sender']['documents']['document'][ 'type'] == 'CPF' assert payment_xml['payment']['sender']['documents']['document'][ 'value'] == get_only_nums(PFPerson().cpf) # Test: _get_payment_xml with CNPJ delattr(order.creator, 'pf_person') order.creator.pj_person = PJPerson() payment_xml = xmltodict.parse( pagseguro._get_payment_xml(payment_method, order)) assert payment_xml['payment']['sender']['documents']['document'][ 'type'] == 'CNPJ' assert payment_xml['payment']['sender']['documents']['document'][ 'value'] == get_only_nums(PJPerson().cnpj) assert payment_xml['payment']['sender']['phone']['areaCode'] == "47" assert payment_xml['payment']['sender']['phone']['number'] == "988212231"
def test_checkout(admin_user): get_default_shop() set_current_theme('shuup.themes.classic_gray') create_default_order_statuses() populate_if_required() create_test_data() default_product = get_default_product() sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop()) sp.default_price = get_default_shop().create_price(Decimal(10.0)) sp.save() service = get_custom_carrier_service() component = SpecificShippingTableBehaviorComponent.objects.create( table=ShippingTable.objects.get(identifier='table-1') ) service.behavior_components.add(component) c = SmartClient() basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 shipping_method = service payment_method = get_payment_method(name="neat", price=4) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) inputs['shipping-postal_code'] = "89060201" inputs['shipping-country'] = "BR" response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == 0 response = c.post( methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } ) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 200 # Phase: Confirm assert Order.objects.count() == 0 confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" assert Order.objects.count() == 1 order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_success_3(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas com juros """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.installments_without_interest = 1 cielo_config.interest_rate = Decimal(3.20) cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction( numero=1, valor=decimal_to_int_cents(ORDER_TOTAL), produto=CieloProduct.Credit, bandeira=CieloCardBrand.Visa, parcelas=CC_VISA_1X_INFO['installments'], tid=tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) assert response.status_code == 200 json_content = json.loads(response.content.decode("utf-8")) assert json_content['redirect_url'].endswith( reverse("shuup:cielo_transaction_return", kwargs={"cielo_order_pk": 1})) choices = InstallmentContext( ORDER_TOTAL, cielo_config).get_intallments_choices() cielo_transaction = CieloTransaction.objects.get(tid=tid) assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit assert abs(cielo_transaction.total_value - choices[3][2]) <= Decimal(0.01) assert cielo_transaction.status.value == transacao.status response = c.post(json_content['redirect_url']) confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() assert abs(order.taxful_total_price.value - choices[3][2]) <= Decimal(0.01) process_payment_path = reverse("shuup:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse( "shuup:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) response = c.get(process_payment_path) response = c.get(process_payment_return_path) cielo_transaction = CieloTransaction.objects.get( order_transaction__order=order, tid=tid) order.refresh_from_db() assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY) assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY) assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_success_3(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas com juros """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.installments_without_interest = 1 cielo_config.interest_rate = Decimal(3.20) cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path,data={"payment_method": payment_method.pk,"shipping_method": shipping_method.pk}) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(numero=1, valor=decimal_to_int_cents(ORDER_TOTAL), produto=CieloProduct.Credit, bandeira=CieloCardBrand.Visa, parcelas=CC_VISA_1X_INFO['installments'], tid=tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) assert response.status_code == 200 json_content = json.loads(response.content.decode("utf-8")) assert json_content['redirect_url'].endswith(reverse("shuup:cielo_transaction_return", kwargs={"cielo_order_pk": 1})) choices = InstallmentContext(ORDER_TOTAL, cielo_config).get_intallments_choices() cielo_transaction = CieloTransaction.objects.get(tid=tid) assert cielo_transaction.cc_product == CieloProduct.InstallmentCredit assert abs(cielo_transaction.total_value - choices[3][2]) <= Decimal(0.01) assert cielo_transaction.status.value == transacao.status response = c.post(json_content['redirect_url']) confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() assert abs(order.taxful_total_price.value - choices[3][2]) <= Decimal(0.01) process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key}) response = c.get(process_payment_path) response = c.get(process_payment_return_path) cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order, tid=tid) order.refresh_from_db() assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY) assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY) assert order.payment_status == PaymentStatus.NOT_PAID
def test_credit_card_fail2(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas - valor total do parcelado diferente do total do pedido """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(1, decimal_to_int_cents(ORDER_TOTAL), CieloProduct.InstallmentCredit, CieloCardBrand.Visa, CC_VISA_4X_INFO['installments'], tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) json_content = json.loads(response.content.decode("utf-8")) response = c.post(json_content['redirect_url']) # ok, no redirect response = c.get(confirm_path) assert response.status_code == 200 # sabotagem: adiciona um item ao carrinho c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) # again, now with redirect response = c.get(confirm_path) assert response.status_code == 302 assert response.url.endswith(payment_path)
def test_credit_card_fail(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas - dados do pagamento nao existem """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class() ) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={"payment_method": payment_method.pk, "shipping_method": shipping_method.pk}) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(1, decimal_to_int_cents(ORDER_TOTAL), CieloProduct.InstallmentCredit, CieloCardBrand.Visa, CC_VISA_4X_INFO['installments'], tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) json_content = json.loads(response.content.decode("utf-8")) response = c.post(json_content['redirect_url']) confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) # FORCE CLEAR ORDER PAYMENT DATA order.payment_data = {} order.save() response = c.get(process_payment_path) order.refresh_from_db() assert order.status == OrderStatus.objects.get_default_canceled()
def test_boleto_cecred_error2(): """ Usuário faz a compra e seleciona boleto como forma de pagamento Boleto CECRED configurado incorretamente Pedido finalizado com sucesso, boleto NÃO é gerado """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, BoletoPaymentProcessor) payment_method = processor.create_service( BankService.CECRED.value, identifier="cecred", shop=get_default_shop(), name="boleto cecred", enabled=True, tax_class=get_default_tax_class()) # Configura de acordo behavior_component = payment_method.behavior_components.first() behavior_component.local_pagamento = "a simple test" behavior_component.cedente = "a simple user" behavior_component.prazo_vencimento = 4 behavior_component.instrucoes = ["line1", "line2"] behavior_component.especie_doc = DocumentType.DM behavior_component.layout = 'v06' behavior_component.agencia = '123431' behavior_component.conta = '6427364732' behavior_component.convenio = '32312' behavior_component.carteira = '12' behavior_component.save() # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == 0 response = c.post( methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } ) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 200 # quando vai gerar boleto estoura uma exceção with patch.object(CecredBoletoBehaviorComponent, 'generate_boleto') as mocked: mocked.side_effect = NotImplementedError() # Phase: Confirm assert Order.objects.count() == 0 confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" assert Order.objects.count() == 1 order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_status == PaymentStatus.NOT_PAID process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key}) order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key}) assert response.url.endswith(process_payment_path), ("Confirm should have redirected to payment page") response = c.get(process_payment_path) assert response.status_code == 302, "Payment page should redirect forth" assert response.url.endswith(process_payment_return_path) response = c.get(process_payment_return_path) assert response.status_code == 302, "Payment return should redirect forth" assert response.url.endswith(order_complete_path) order.refresh_from_db() assert order.payment_status == PaymentStatus.NOT_PAID # BOLETO NÃO EXISTE assert not hasattr(order, 'boleto') assert not StoredBoleto.objects.filter(order=order).exists()
def test_credit_card_fail2(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Sem URL para autenticação - 4 parcelas - valor total do parcelado diferente do total do pedido """ initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) ORDER_TOTAL = PRODUCT_PRICE * 10 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() # aumenta o limite máximo de parcelas para 4 cielo_config = get_cielo_config() cielo_config.max_installments = 4 cielo_config.save() payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class() ) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) transaction_path = reverse("shuup:cielo_make_transaction") confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={"payment_method": payment_method.pk, "shipping_method": shipping_method.pk}) c.get(confirm_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(1, decimal_to_int_cents(ORDER_TOTAL), CieloProduct.InstallmentCredit, CieloCardBrand.Visa, CC_VISA_4X_INFO['installments'], tid, return_url=None) transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: pay c.soup(payment_path) response = c.post(transaction_path, CC_VISA_4X_INFO) json_content = json.loads(response.content.decode("utf-8")) response = c.post(json_content['redirect_url']) # ok, no redirect response = c.get(confirm_path) assert response.status_code == 200 # sabotagem: adiciona um item ao carrinho c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 10, "supplier": get_default_supplier().pk }) # again, now with redirect response = c.get(confirm_path) assert response.status_code == 302 assert response.url.endswith(payment_path)
def test_admin(rf, admin_user): initialize() c = SmartClient() default_product = get_default_product() basket_path = reverse("shuup:basket") c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) shipping_method = get_default_shipping_method() processor = get_payment_provider() payment_method = processor.create_service( PagSeguroPaymentMethod.ONLINE_DEBIT.value, identifier="pagseguro_debit", shop=get_default_shop(), name="debit", enabled=True, tax_class=get_default_tax_class()) service_choices = processor.get_service_choices() assert len(service_choices) == 2 assert service_choices[0].identifier == PagSeguroPaymentMethod.BOLETO.value assert service_choices[ 1].identifier == PagSeguroPaymentMethod.ONLINE_DEBIT.value addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) c.post(addresses_path, data=inputs) c.post(methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk }) c.get(confirm_path) c.soup(payment_path) c.post( payment_path, { "paymentMethod": PagSeguroPaymentMethodIdentifier.Debito, "bankOption": "{0}".format(PagSeguroPaymentMethodCode.DebitoOnlineBB.value), "senderHash": "J7E98Y37WEIRUHDIAI9U8RYE7UQE" }) confirm_soup = c.soup(confirm_path) c.post(confirm_path, data=extract_form_fields(confirm_soup)) order = Order.objects.filter(payment_method=payment_method).first() payment = PagSeguroPayment.objects.create(order=order, code="u3928uhu8y9i3") PagSeguroOrderSection() PagSeguroOrderSection.get_context_data(order) assert PagSeguroOrderSection.visible_for_object(order) is True view = load("shuup_pagseguro.admin.views.PaymentRefreshView").as_view() request = apply_request_middleware(rf.post("/"), user=admin_user) response = view(request) assert response.status_code == 400 request = apply_request_middleware(rf.post("/", {"pk": payment.pk}), user=admin_user) response = view(request) assert response.status_code == 200 # somente visita view = load("shuup_pagseguro.admin.views.config.ConfigListView").as_view() request = apply_request_middleware(rf.get("/"), user=admin_user) response = view(request) assert response.status_code == 200 view = load("shuup_pagseguro.admin.views.DashboardView").as_view() request = apply_request_middleware(rf.get("/"), user=admin_user) response = view(request) assert response.status_code == 200
def test_order_flow_with_payment_phase_credit_card_success(): """ Caso: - Transação com Cartão de Crédito - Auto captura desabilidato - Com URL para autenticação - 1 parcela sem juros """ initialize() c = SmartClient() default_product = get_default_product() ORDER_TOTAL = PRODUCT_PRICE * 1 basket_path = reverse("shuup:basket") add_to_basket_resp = c.post(basket_path, data={ "command": "add", "product_id": default_product.pk, "quantity": 1, "supplier": get_default_supplier().pk }) assert add_to_basket_resp.status_code < 400 # Create methods shipping_method = get_default_shipping_method() processor = get_payment_provider() assert isinstance(processor, CieloPaymentProcessor) payment_method = processor.create_service( CIELO_SERVICE_CREDIT, identifier="cielo_phase_cc", shop=get_default_shop(), name="credit card", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"}) transaction_path = reverse("shuup:cielo_make_transaction") # Phase: Addresses addresses_soup = c.soup(addresses_path) inputs = fill_address_inputs(addresses_soup, with_company=False) response = c.post(addresses_path, data=inputs) assert response.status_code == 302, "Address phase should redirect forth" assert response.url.endswith(methods_path) # Phase: Methods assert Order.objects.filter(payment_method=payment_method).count() == 0 response = c.post( methods_path, data={ "payment_method": payment_method.pk, "shipping_method": shipping_method.pk } ) assert response.status_code == 302, "Methods phase should redirect forth" assert response.url.endswith(confirm_path) response = c.get(confirm_path) assert response.status_code == 302, "Confirm should first redirect forth" assert response.url.endswith(payment_path) tid = uuid.uuid4().hex transacao = get_in_progress_transaction(numero=1, valor=decimal_to_int_cents(ORDER_TOTAL), produto=CieloProduct.Credit, bandeira=CieloCardBrand.Visa, parcelas=CC_VISA_1X_INFO['installments'], tid=tid) with patch.object(CieloRequest, 'autorizar', return_value=transacao): with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: Payment response = c.soup(payment_path) response = c.post(transaction_path, CC_VISA_1X_INFO) assert response.status_code == 200 json_content = json.loads(response.content.decode("utf-8")) assert json_content['redirect_url'] == AUTH_URL cielo_transaction = CieloTransaction.objects.get(tid=tid) assert cielo_transaction.status == CieloTransactionStatus.InProgress assert cielo_transaction.cc_brand == CC_VISA_1X_INFO['cc_brand'] assert cielo_transaction.cc_holder == CC_VISA_1X_INFO['cc_holder'] assert cielo_transaction.installments == CC_VISA_1X_INFO['installments'] assert cielo_transaction.cc_product == CieloProduct.Credit assert abs(cielo_transaction.total_value - ORDER_TOTAL) < 0.01 assert cielo_transaction.status.value == transacao.status transacao = get_approved_transaction(transacao) with patch.object(CieloRequest, 'consultar', return_value=transacao): # Phase: Confirm Order assert Order.objects.count() == 0 confirm_soup = c.soup(confirm_path) response = c.post(confirm_path, data=extract_form_fields(confirm_soup)) assert response.status_code == 302, "Confirm should redirect forth" assert Order.objects.count() == 1 order = Order.objects.filter(payment_method=payment_method).first() process_payment_path = reverse("shuup:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse("shuup:order_process_payment_return",kwargs={"pk": order.pk, "key": order.key}) order_complete_path = reverse("shuup:order_complete",kwargs={"pk": order.pk, "key": order.key}) # Visit payment page response = c.get(process_payment_path) assert response.status_code == 302, "Payment page should redirect forth" assert response.url.endswith(process_payment_return_path) # Check payment return response = c.get(process_payment_return_path) assert response.status_code == 302, "Payment return should redirect forth" assert response.url.endswith(order_complete_path) cielo_transaction = CieloTransaction.objects.get(order_transaction__order=order, tid=tid) assert cielo_transaction.status == CieloTransactionStatus.Authorized assert cielo_transaction.authorization_nsu == str(transacao.autorizacao.nsu) assert cielo_transaction.authorization_lr == str(transacao.autorizacao.lr) assert cielo_transaction.authorization_date == iso8601.parse_date(transacao.autorizacao.data_hora) assert cielo_transaction.authentication_eci == transacao.autenticacao.eci assert cielo_transaction.authentication_date == iso8601.parse_date(transacao.autenticacao.data_hora) assert cielo_transaction.total_captured.value == Decimal() assert cielo_transaction.total_reversed.value == Decimal() order.refresh_from_db() assert order.payment_data.get(CIELO_TRANSACTION_ID_KEY) assert order.payment_data.get(CIELO_ORDER_TRANSACTION_ID_KEY) assert order.payment_status == PaymentStatus.NOT_PAID