mirror of
https://github.com/juspay/hyperswitch.git
synced 2025-10-29 00:49:42 +08:00
583 lines
20 KiB
Rust
583 lines
20 KiB
Rust
use std::str::FromStr;
|
|
|
|
use common_utils::{pii::Email, types::MinorUnit};
|
|
use diesel_models::types::OrderDetailsWithAmount;
|
|
use hyperswitch_domain_models::address::{Address, AddressDetails};
|
|
use masking::Secret;
|
|
use router::types::{self, domain, storage::enums, PaymentAddress};
|
|
|
|
use crate::{
|
|
connector_auth,
|
|
utils::{self, ConnectorActions, PaymentAuthorizeType},
|
|
};
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct PaymeTest;
|
|
impl ConnectorActions for PaymeTest {}
|
|
impl utils::Connector for PaymeTest {
|
|
fn get_data(&self) -> types::api::ConnectorData {
|
|
use router::connector::Payme;
|
|
utils::construct_connector_data_old(
|
|
Box::new(Payme::new()),
|
|
types::Connector::Payme,
|
|
types::api::GetToken::Connector,
|
|
None,
|
|
)
|
|
}
|
|
|
|
fn get_auth_token(&self) -> types::ConnectorAuthType {
|
|
utils::to_connector_auth_type(
|
|
connector_auth::ConnectorAuthentication::new()
|
|
.payme
|
|
.expect("Missing connector authentication configuration")
|
|
.into(),
|
|
)
|
|
}
|
|
|
|
fn get_name(&self) -> String {
|
|
"payme".to_string()
|
|
}
|
|
}
|
|
|
|
static CONNECTOR: PaymeTest = PaymeTest {};
|
|
|
|
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
|
|
Some(utils::PaymentInfo {
|
|
address: Some(PaymentAddress::new(
|
|
None,
|
|
Some(Address {
|
|
address: Some(AddressDetails {
|
|
city: None,
|
|
country: None,
|
|
line1: None,
|
|
line2: None,
|
|
line3: None,
|
|
zip: None,
|
|
state: None,
|
|
first_name: Some(Secret::new("John".to_string())),
|
|
last_name: Some(Secret::new("Doe".to_string())),
|
|
origin_zip: None,
|
|
}),
|
|
phone: None,
|
|
email: None,
|
|
}),
|
|
None,
|
|
None,
|
|
)),
|
|
auth_type: None,
|
|
access_token: None,
|
|
connector_meta_data: None,
|
|
connector_customer: None,
|
|
payment_method_token: None,
|
|
#[cfg(feature = "payouts")]
|
|
currency: None,
|
|
#[cfg(feature = "payouts")]
|
|
payout_method_data: None,
|
|
})
|
|
}
|
|
|
|
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
|
|
Some(types::PaymentsAuthorizeData {
|
|
order_details: Some(vec![OrderDetailsWithAmount {
|
|
product_name: "iphone 13".to_string(),
|
|
quantity: 1,
|
|
amount: MinorUnit::new(1000),
|
|
product_img_link: None,
|
|
requires_shipping: None,
|
|
product_id: None,
|
|
category: None,
|
|
sub_category: None,
|
|
brand: None,
|
|
product_type: None,
|
|
product_tax_code: None,
|
|
tax_rate: None,
|
|
total_tax_amount: None,
|
|
description: None,
|
|
sku: None,
|
|
upc: None,
|
|
commodity_code: None,
|
|
unit_of_measure: None,
|
|
total_amount: None,
|
|
unit_discount_amount: None,
|
|
}]),
|
|
router_return_url: Some("https://hyperswitch.io".to_string()),
|
|
webhook_url: Some("https://hyperswitch.io".to_string()),
|
|
email: Some(Email::from_str("test@gmail.com").unwrap()),
|
|
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
|
|
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
|
|
card_cvc: Secret::new("123".to_string()),
|
|
card_exp_month: Secret::new("10".to_string()),
|
|
card_exp_year: Secret::new("2025".to_string()),
|
|
..utils::CCardType::default().0
|
|
}),
|
|
amount: 1000,
|
|
..PaymentAuthorizeType::default().0
|
|
})
|
|
}
|
|
|
|
// Cards Positive Tests
|
|
// Creates a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_only_authorize_payment() {
|
|
let response = CONNECTOR
|
|
.authorize_payment(payment_method_details(), get_default_payment_info())
|
|
.await
|
|
.expect("Authorize payment response");
|
|
assert_eq!(response.status, enums::AttemptStatus::Authorized);
|
|
}
|
|
|
|
// Captures a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_capture_authorized_payment() {
|
|
let response = CONNECTOR
|
|
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
|
|
.await
|
|
.expect("Capture payment response");
|
|
assert_eq!(response.status, enums::AttemptStatus::Charged);
|
|
}
|
|
|
|
// Partially captures a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not support partial capture"]
|
|
async fn should_partially_capture_authorized_payment() {
|
|
let response = CONNECTOR
|
|
.authorize_and_capture_payment(
|
|
payment_method_details(),
|
|
Some(types::PaymentsCaptureData {
|
|
amount_to_capture: 50,
|
|
..utils::PaymentCaptureType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.expect("Capture payment response");
|
|
assert_eq!(response.status, enums::AttemptStatus::Charged);
|
|
}
|
|
|
|
// Synchronizes a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports sync"]
|
|
async fn should_sync_authorized_payment() {
|
|
let authorize_response = CONNECTOR
|
|
.authorize_payment(payment_method_details(), get_default_payment_info())
|
|
.await
|
|
.expect("Authorize payment response");
|
|
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
|
|
let response = CONNECTOR
|
|
.psync_retry_till_status_matches(
|
|
enums::AttemptStatus::Authorized,
|
|
Some(types::PaymentsSyncData {
|
|
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
|
|
txn_id.unwrap(),
|
|
),
|
|
..Default::default()
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.expect("PSync response");
|
|
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
|
|
}
|
|
|
|
// Voids a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports void"]
|
|
async fn should_void_authorized_payment() {
|
|
let response = CONNECTOR
|
|
.authorize_and_void_payment(
|
|
payment_method_details(),
|
|
Some(types::PaymentsCancelData {
|
|
connector_transaction_id: String::from(""),
|
|
cancellation_reason: Some("requested_by_customer".to_string()),
|
|
..Default::default()
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"Void flow not supported by Payme connector".to_string()
|
|
);
|
|
}
|
|
|
|
// Refunds a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_refund_manually_captured_payment() {
|
|
let response = CONNECTOR
|
|
.capture_payment_and_refund(
|
|
payment_method_details(),
|
|
None,
|
|
None,
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap().refund_status,
|
|
enums::RefundStatus::Success,
|
|
);
|
|
}
|
|
|
|
// Partially refunds a payment using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_partially_refund_manually_captured_payment() {
|
|
let response = CONNECTOR
|
|
.capture_payment_and_refund(
|
|
payment_method_details(),
|
|
None,
|
|
Some(types::RefundsData {
|
|
..utils::PaymentRefundType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap().refund_status,
|
|
enums::RefundStatus::Success,
|
|
);
|
|
}
|
|
|
|
// Synchronizes a refund using the manual capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports sync"]
|
|
async fn should_sync_manually_captured_refund() {
|
|
let refund_response = CONNECTOR
|
|
.capture_payment_and_refund(
|
|
payment_method_details(),
|
|
None,
|
|
None,
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let response = CONNECTOR
|
|
.rsync_retry_till_status_matches(
|
|
enums::RefundStatus::Success,
|
|
refund_response.response.unwrap().connector_refund_id,
|
|
None,
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap().refund_status,
|
|
enums::RefundStatus::Success,
|
|
);
|
|
}
|
|
|
|
// Creates a payment using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_make_payment() {
|
|
let authorize_response = CONNECTOR
|
|
.make_payment(payment_method_details(), get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
|
|
}
|
|
|
|
// Synchronizes a payment using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports sync"]
|
|
async fn should_sync_auto_captured_payment() {
|
|
let authorize_response = CONNECTOR
|
|
.make_payment(payment_method_details(), get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
|
|
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
|
|
assert_ne!(txn_id, None, "Empty connector transaction id");
|
|
let response = CONNECTOR
|
|
.psync_retry_till_status_matches(
|
|
enums::AttemptStatus::Charged,
|
|
Some(types::PaymentsSyncData {
|
|
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
|
|
txn_id.unwrap(),
|
|
),
|
|
capture_method: Some(enums::CaptureMethod::Automatic),
|
|
..Default::default()
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(response.status, enums::AttemptStatus::Charged,);
|
|
}
|
|
|
|
// Refunds a payment using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_refund_auto_captured_payment() {
|
|
let response = CONNECTOR
|
|
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap().refund_status,
|
|
enums::RefundStatus::Success,
|
|
);
|
|
}
|
|
|
|
// Partially refunds a payment using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_partially_refund_succeeded_payment() {
|
|
let refund_response = CONNECTOR
|
|
.make_payment_and_refund(
|
|
payment_method_details(),
|
|
Some(types::RefundsData {
|
|
..utils::PaymentRefundType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
refund_response.response.unwrap().refund_status,
|
|
enums::RefundStatus::Success,
|
|
);
|
|
}
|
|
|
|
// Creates multiple refunds against a payment using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
async fn should_refund_succeeded_payment_multiple_times() {
|
|
CONNECTOR
|
|
.make_payment_and_multiple_refund(
|
|
payment_method_details(),
|
|
Some(types::RefundsData {
|
|
refund_amount: 100,
|
|
..utils::PaymentRefundType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await;
|
|
}
|
|
|
|
// Synchronizes a refund using the automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports sync"]
|
|
async fn should_sync_refund() {
|
|
let refund_response = CONNECTOR
|
|
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
let response = CONNECTOR
|
|
.rsync_retry_till_status_matches(
|
|
enums::RefundStatus::Success,
|
|
refund_response.response.unwrap().connector_refund_id,
|
|
None,
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"Refund Sync flow not supported by Payme connector",
|
|
);
|
|
}
|
|
|
|
// Cards Negative scenarios
|
|
// Creates a payment with incorrect CVC.
|
|
#[actix_web::test]
|
|
async fn should_fail_payment_for_incorrect_cvc() {
|
|
let response = CONNECTOR
|
|
.make_payment(
|
|
Some(types::PaymentsAuthorizeData {
|
|
amount: 100,
|
|
currency: enums::Currency::ILS,
|
|
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
|
|
card_cvc: Secret::new("12345".to_string()),
|
|
..utils::CCardType::default().0
|
|
}),
|
|
order_details: Some(vec![OrderDetailsWithAmount {
|
|
product_name: "iphone 13".to_string(),
|
|
quantity: 1,
|
|
amount: MinorUnit::new(1000),
|
|
product_img_link: None,
|
|
requires_shipping: None,
|
|
product_id: None,
|
|
category: None,
|
|
sub_category: None,
|
|
brand: None,
|
|
product_type: None,
|
|
product_tax_code: None,
|
|
tax_rate: None,
|
|
total_tax_amount: None,
|
|
description: None,
|
|
sku: None,
|
|
upc: None,
|
|
commodity_code: None,
|
|
unit_of_measure: None,
|
|
total_amount: None,
|
|
unit_discount_amount: None,
|
|
}]),
|
|
router_return_url: Some("https://hyperswitch.io".to_string()),
|
|
webhook_url: Some("https://hyperswitch.io".to_string()),
|
|
email: Some(Email::from_str("test@gmail.com").unwrap()),
|
|
..PaymentAuthorizeType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"internal_server_error".to_string(),
|
|
);
|
|
}
|
|
|
|
// Creates a payment with incorrect expiry month.
|
|
#[actix_web::test]
|
|
async fn should_fail_payment_for_invalid_exp_month() {
|
|
let response = CONNECTOR
|
|
.make_payment(
|
|
Some(types::PaymentsAuthorizeData {
|
|
amount: 100,
|
|
currency: enums::Currency::ILS,
|
|
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
|
|
card_exp_month: Secret::new("20".to_string()),
|
|
..utils::CCardType::default().0
|
|
}),
|
|
order_details: Some(vec![OrderDetailsWithAmount {
|
|
product_name: "iphone 13".to_string(),
|
|
quantity: 1,
|
|
amount: MinorUnit::new(1000),
|
|
product_img_link: None,
|
|
requires_shipping: None,
|
|
product_id: None,
|
|
category: None,
|
|
sub_category: None,
|
|
brand: None,
|
|
product_type: None,
|
|
product_tax_code: None,
|
|
tax_rate: None,
|
|
total_tax_amount: None,
|
|
description: None,
|
|
sku: None,
|
|
upc: None,
|
|
commodity_code: None,
|
|
unit_of_measure: None,
|
|
total_amount: None,
|
|
unit_discount_amount: None,
|
|
}]),
|
|
router_return_url: Some("https://hyperswitch.io".to_string()),
|
|
webhook_url: Some("https://hyperswitch.io".to_string()),
|
|
email: Some(Email::from_str("test@gmail.com").unwrap()),
|
|
..PaymentAuthorizeType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"internal_server_error".to_string(),
|
|
);
|
|
}
|
|
|
|
// Creates a payment with incorrect expiry year.
|
|
#[actix_web::test]
|
|
async fn should_fail_payment_for_incorrect_expiry_year() {
|
|
let response = CONNECTOR
|
|
.make_payment(
|
|
Some(types::PaymentsAuthorizeData {
|
|
amount: 100,
|
|
currency: enums::Currency::ILS,
|
|
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
|
|
card_exp_year: Secret::new("2012".to_string()),
|
|
..utils::CCardType::default().0
|
|
}),
|
|
order_details: Some(vec![OrderDetailsWithAmount {
|
|
product_name: "iphone 13".to_string(),
|
|
quantity: 1,
|
|
amount: MinorUnit::new(1000),
|
|
product_img_link: None,
|
|
requires_shipping: None,
|
|
product_id: None,
|
|
category: None,
|
|
sub_category: None,
|
|
brand: None,
|
|
product_type: None,
|
|
product_tax_code: None,
|
|
tax_rate: None,
|
|
total_tax_amount: None,
|
|
description: None,
|
|
sku: None,
|
|
upc: None,
|
|
commodity_code: None,
|
|
unit_of_measure: None,
|
|
total_amount: None,
|
|
unit_discount_amount: None,
|
|
}]),
|
|
router_return_url: Some("https://hyperswitch.io".to_string()),
|
|
webhook_url: Some("https://hyperswitch.io".to_string()),
|
|
email: Some(Email::from_str("test@gmail.com").unwrap()),
|
|
..PaymentAuthorizeType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"internal_server_error".to_string(),
|
|
);
|
|
}
|
|
|
|
// Voids a payment using automatic capture flow (Non 3DS).
|
|
#[actix_web::test]
|
|
#[ignore = "Connector does not supports void"]
|
|
async fn should_fail_void_payment_for_auto_capture() {
|
|
let authorize_response = CONNECTOR
|
|
.make_payment(payment_method_details(), get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
|
|
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
|
|
assert_ne!(txn_id, None, "Empty connector transaction id");
|
|
let void_response = CONNECTOR
|
|
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
void_response.response.unwrap_err().message,
|
|
"Void flow not supported by Payme connector"
|
|
);
|
|
}
|
|
|
|
// Captures a payment using invalid connector payment id.
|
|
#[actix_web::test]
|
|
async fn should_fail_capture_for_invalid_payment() {
|
|
let capture_response = CONNECTOR
|
|
.capture_payment("123456789".to_string(), None, get_default_payment_info())
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
capture_response.response.unwrap_err().message,
|
|
String::from("internal_server_error")
|
|
);
|
|
}
|
|
|
|
// Refunds a payment with refund amount higher than payment amount.
|
|
#[actix_web::test]
|
|
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
|
|
let response = CONNECTOR
|
|
.make_payment_and_refund(
|
|
payment_method_details(),
|
|
Some(types::RefundsData {
|
|
refund_amount: 1500,
|
|
..utils::PaymentRefundType::default().0
|
|
}),
|
|
get_default_payment_info(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
response.response.unwrap_err().message,
|
|
"internal_server_error",
|
|
);
|
|
}
|
|
|
|
// Connector dependent test cases goes here
|
|
|
|
// [#478]: add unit tests for non 3DS, wallets & webhooks in connector tests
|