rust/hyperswitch
1
0
Fork 0
mirror of https://github.com/juspay/hyperswitch.git synced 2025-10-31 10:06:32 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
hyperswitch/crates/router/tests/payments.rs

790 lines
26 KiB
Rust
Raw Blame History

#![allow(
clippy::expect_used,
clippy::unwrap_in_result,
clippy::unwrap_used,
clippy::print_stdout
)]
mod utils;
use std::{borrow::Cow, sync::Arc};
use common_utils::{id_type, types::MinorUnit};
use router::{
configs,
core::payments,
db::StorageImpl,
routes, services,
types::{
self,
api::{self, enums as api_enums},
},
};
use time::macros::datetime;
use tokio::sync::oneshot;
use uuid::Uuid;
// setting the connector in environment variables doesn't work when run in parallel. Neither does passing the paymentid
// do we'll test refund and payment in same tests and later implement thread_local variables.
// When test-connector feature is enabled, you can pass the connector name in description
#[actix_web::test]
#[ignore]
// verify the API-KEY/merchant id has stripe as first choice
async fn payments_create_stripe() {
Box::pin(utils::setup()).await;
let payment_id = format!("test_{}", Uuid::new_v4());
let api_key = ("API-KEY", "MySecretApiKey");
let request = serde_json::json!({
"payment_id" : payment_id,
"merchant_id" : "jarnura",
"amount" : 1000,
"currency" : "USD",
"amount_to_capture" : 1000,
"confirm" : true,
"customer" : "test_customer",
"customer_email" : "test@gmail.com",
"customer_name" : "Test",
"description" : "stripe",
"return_url" : "https://juspay.in/",
"payment_method_data" : {"card" : {"card_number":"4242424242424242","card_exp_month":"12","card_exp_year":"29","card_holder_name":"JohnDoe","card_cvc":"123"}},
"payment_method" : "card",
"statement_descriptor_name" : "Test Merchant",
"statement_descriptor_suffix" : "US"
});
let refund_req = serde_json::json!({
"amount" : 1000,
"currency" : "USD",
"refund_id" : "refund_123",
"payment_id" : payment_id,
"merchant_id" : "jarnura",
});
let client = awc::Client::default();
let mut create_response = client
.post("http://127.0.0.1:8080/payments/create")
.insert_header(api_key)
.send_json(&request)
.await
.unwrap();
let create_response_body = create_response.body().await;
println!("{create_response:?} : {create_response_body:?}");
assert_eq!(create_response.status(), awc::http::StatusCode::OK);
let mut retrieve_response = client
.get("http://127.0.0.1:8080/payments/retrieve")
.insert_header(api_key)
.send_json(&request)
.await
.unwrap();
let retrieve_response_body = retrieve_response.body().await;
println!("{retrieve_response:?} =:= {retrieve_response_body:?}");
assert_eq!(retrieve_response.status(), awc::http::StatusCode::OK);
let mut refund_response = client
.post("http://127.0.0.1:8080/refunds/create")
.insert_header(api_key)
.send_json(&refund_req)
.await
.unwrap();
let refund_response_body = refund_response.body().await;
println!("{refund_response:?} =:= {refund_response_body:?}");
assert_eq!(refund_response.status(), awc::http::StatusCode::OK);
}
#[actix_web::test]
#[ignore]
// verify the API-KEY/merchant id has adyen as first choice
async fn payments_create_adyen() {
Box::pin(utils::setup()).await;
let payment_id = format!("test_{}", Uuid::new_v4());
let api_key = ("API-KEY", "321");
let request = serde_json::json!({
"payment_id" : payment_id,
"merchant_id" : "jarnura",
"amount" : 1000,
"currency" : "USD",
"amount_to_capture" : 1000,
"confirm" : true,
"customer" : "test_customer",
"customer_email" : "test@gmail.com",
"customer_name" : "Test",
"description" : "adyen",
"return_url" : "https://juspay.in/",
"payment_method_data" : {"card" : {"card_number":"5555 3412 4444 1115","card_exp_month":"03","card_exp_year":"2030","card_holder_name":"JohnDoe","card_cvc":"737"}},
"payment_method" : "card",
"statement_descriptor_name" : "Test Merchant",
"statement_descriptor_suffix" : "US"
});
let refund_req = serde_json::json!({
"amount" : 1000,
"currency" : "USD",
"refund_id" : "refund_123",
"payment_id" : payment_id,
"merchant_id" : "jarnura",
});
let client = awc::Client::default();
let mut create_response = client
.post("http://127.0.0.1:8080/payments/create")
.insert_header(api_key) //API Key must have adyen as first choice
.send_json(&request)
.await
.unwrap();
let create_response_body = create_response.body().await;
println!("{create_response:?} : {create_response_body:?}");
assert_eq!(create_response.status(), awc::http::StatusCode::OK);
let mut retrieve_response = client
.get("http://127.0.0.1:8080/payments/retrieve")
.insert_header(api_key)
.send_json(&request)
.await
.unwrap();
let retrieve_response_body = retrieve_response.body().await;
println!("{retrieve_response:?} =:= {retrieve_response_body:?}");
assert_eq!(retrieve_response.status(), awc::http::StatusCode::OK);
let mut refund_response = client
.post("http://127.0.0.1:8080/refunds/create")
.insert_header(api_key)
.send_json(&refund_req)
.await
.unwrap();
let refund_response_body = refund_response.body().await;
println!("{refund_response:?} =:= {refund_response_body:?}");
assert_eq!(refund_response.status(), awc::http::StatusCode::OK);
}
#[actix_web::test]
// verify the API-KEY/merchant id has stripe as first choice
#[ignore]
async fn payments_create_fail() {
Box::pin(utils::setup()).await;
let payment_id = format!("test_{}", Uuid::new_v4());
let api_key = ("API-KEY", "MySecretApiKey");
let invalid_request = serde_json::json!({
"description" : "stripe",
});
let request = serde_json::json!({
"payment_id" : payment_id,
"merchant_id" : "jarnura",
"amount" : 1000,
"currency" : "USD",
"amount_to_capture" : 1000,
"confirm" : true,
"customer" : "test_customer",
"customer_email" : "test@gmail.com",
"customer_name" : "Test",
"description" : "adyen",
"return_url" : "https://juspay.in/",
"payment_method_data" : {"card" : {"card_number":"5555 3412 4444 1115","card_exp_month":"03","card_exp_year":"2030","card_holder_name":"JohnDoe","card_cvc":"737"}},
"payment_method" : "card",
"statement_descriptor_name" : "Test Merchant",
"statement_descriptor_suffix" : "US"
});
let client = awc::Client::default();
let mut invalid_response = client
.post("http://127.0.0.1:8080/payments/create")
.insert_header(api_key)
.send_json(&invalid_request)
.await
.unwrap();
let invalid_response_body = invalid_response.body().await;
println!("{invalid_response:?} : {invalid_response_body:?}");
assert_eq!(
invalid_response.status(),
awc::http::StatusCode::BAD_REQUEST
);
let mut api_key_response = client
.get("http://127.0.0.1:8080/payments/retrieve")
// .insert_header(api_key)
.send_json(&request)
.await
.unwrap();
let api_key_response_body = api_key_response.body().await;
println!("{api_key_response:?} =:= {api_key_response_body:?}");
assert_eq!(
api_key_response.status(),
awc::http::StatusCode::UNAUTHORIZED
);
}
#[actix_web::test]
#[ignore]
async fn payments_todo() {
Box::pin(utils::setup()).await;
let client = awc::Client::default();
let mut response;
let mut response_body;
let _post_endpoints = ["123/update", "123/confirm", "cancel"];
let get_endpoints = vec!["list"];
for endpoint in get_endpoints {
response = client
.get(format!("http://127.0.0.1:8080/payments/{endpoint}"))
.insert_header(("API-KEY", "MySecretApiKey"))
.send()
.await
.unwrap();
response_body = response.body().await;
println!("{endpoint} =:= {response:?} : {response_body:?}");
assert_eq!(response.status(), awc::http::StatusCode::OK);
}
// for endpoint in post_endpoints {
// response = client
// .post(format!("http://127.0.0.1:8080/payments/{}", endpoint))
// .send()
// .await
// .unwrap();
// response_body = response.body().await;
// println!("{} =:= {:?} : {:?}", endpoint, response, response_body);
// assert_eq!(response.status(), awc::http::StatusCode::OK);
// }
}
#[test]
fn connector_list() {
let connector_list = types::ConnectorsList {
connectors: vec![String::from("stripe"), "adyen".to_string()],
};
let json = serde_json::to_string(&connector_list).unwrap();
println!("{}", &json);
let newlist: types::ConnectorsList = serde_json::from_str(&json).unwrap();
println!("{newlist:#?}");
assert_eq!(true, true);
}
#[cfg(feature = "v1")]
#[actix_rt::test]
#[ignore] // AWS
async fn payments_create_core() {
use configs::settings::Settings;
use hyperswitch_domain_models::merchant_context::{Context, MerchantContext};
let conf = Settings::new().expect("invalid settings");
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let merchant_id = id_type::MerchantId::try_from(Cow::from("juspay_merchant")).unwrap();
let state = Arc::new(app_state)
.get_session_state(
&id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
let key_manager_state = &(&state).into();
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
key_manager_state,
&merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.unwrap();
let merchant_account = state
.store
.find_merchant_account_by_merchant_id(key_manager_state, &merchant_id, &key_store)
.await
.unwrap();
let merchant_context = MerchantContext::NormalMerchant(Box::new(Context(
merchant_account.clone(),
key_store.clone(),
)));
let payment_id =
id_type::PaymentId::try_from(Cow::Borrowed("pay_mbabizu24mvu3mela5njyhpit10")).unwrap();
let req = api::PaymentsRequest {
payment_id: Some(api::PaymentIdType::PaymentIntentId(payment_id.clone())),
merchant_id: Some(merchant_id.clone()),
amount: Some(MinorUnit::new(6540).into()),
currency: Some(api_enums::Currency::USD),
capture_method: Some(api_enums::CaptureMethod::Automatic),
amount_to_capture: Some(MinorUnit::new(6540)),
capture_on: Some(datetime!(2022-09-10 11:12)),
confirm: Some(true),
customer_id: None,
email: None,
name: None,
description: Some("Its my first payment request".to_string()),
return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
setup_future_usage: Some(api_enums::FutureUsage::OnSession),
authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
payment_method_data: Some(api::PaymentMethodDataRequest {
payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
card_number: "4242424242424242".to_string().try_into().unwrap(),
card_exp_month: "10".to_string().into(),
card_exp_year: "35".to_string().into(),
card_holder_name: Some(masking::Secret::new("Arun Raj".to_string())),
card_cvc: "123".to_string().into(),
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
nick_name: Some(masking::Secret::new("nick_name".into())),
})),
billing: None,
}),
payment_method: Some(api_enums::PaymentMethod::Card),
shipping: Some(api::Address {
address: None,
phone: None,
email: None,
}),
billing: Some(api::Address {
address: None,
phone: None,
email: None,
}),
statement_descriptor_name: Some("Hyperswtich".to_string()),
statement_descriptor_suffix: Some("Hyperswitch".to_string()),
..Default::default()
};
let expected_response = api::PaymentsResponse {
payment_id,
status: api_enums::IntentStatus::Succeeded,
amount: MinorUnit::new(6540),
amount_capturable: MinorUnit::new(0),
amount_received: None,
client_secret: None,
created: None,
currency: "USD".to_string(),
customer_id: None,
description: Some("Its my first payment request".to_string()),
refunds: None,
mandate_id: None,
merchant_id,
net_amount: MinorUnit::new(6540),
connector: None,
customer: None,
disputes: None,
attempts: None,
captures: None,
mandate_data: None,
setup_future_usage: None,
off_session: None,
capture_on: None,
capture_method: None,
payment_method: None,
payment_method_data: None,
payment_token: None,
shipping: None,
billing: None,
order_details: None,
email: None,
name: None,
phone: None,
return_url: None,
authentication_type: None,
statement_descriptor_name: None,
statement_descriptor_suffix: None,
next_action: None,
cancellation_reason: None,
error_code: None,
error_message: None,
unified_code: None,
unified_message: None,
payment_experience: None,
payment_method_type: None,
connector_label: None,
business_country: None,
business_label: None,
business_sub_label: None,
allowed_payment_method_types: None,
ephemeral_key: None,
manual_retry_allowed: None,
connector_transaction_id: None,
frm_message: None,
metadata: None,
connector_metadata: None,
feature_metadata: None,
reference_id: None,
payment_link: None,
profile_id: None,
surcharge_details: None,
attempt_count: 1,
merchant_decision: None,
merchant_connector_id: None,
incremental_authorization_allowed: None,
authorization_count: None,
incremental_authorizations: None,
external_authentication_details: None,
external_3ds_authentication_attempted: None,
expires_on: None,
fingerprint: None,
mit_category: None,
browser_info: None,
payment_method_id: None,
payment_method_status: None,
updated: None,
split_payments: None,
frm_metadata: None,
merchant_order_reference_id: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_id: None,
shipping_cost: None,
card_discovery: None,
force_3ds_challenge: None,
force_3ds_challenge_trigger: None,
issuer_error_code: None,
issuer_error_message: None,
is_iframe_redirection_enabled: None,
whole_connector_response: None,
payment_channel: None,
network_transaction_id: None,
enable_partial_authorization: None,
is_overcapture_enabled: None,
enable_overcapture: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
};
let expected_response =
services::ApplicationResponse::JsonWithHeaders((expected_response, vec![]));
let actual_response = Box::pin(payments::payments_core::<
api::Authorize,
api::PaymentsResponse,
_,
_,
_,
payments::PaymentData<api::Authorize>,
>(
state.clone(),
state.get_req_state(),
merchant_context,
None,
payments::PaymentCreate,
req,
services::AuthFlow::Merchant,
payments::CallConnectorAction::Trigger,
None,
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await
.unwrap();
assert_eq!(expected_response, actual_response);
}
// #[actix_rt::test]
// async fn payments_start_core_stripe_redirect() {
// use configs::settings::Settings;
// let conf = Settings::new().expect("invalid settings");
// let state = routes::AppState {
// flow_name: String::from("default"),
// pg_conn: connection::pg_connection_read(&conf),
// redis_conn: connection::redis_connection(&conf).await,
// };
// let customer_id = format!("cust_{}", Uuid::new_v4());
// let merchant_id = "jarnura".to_string();
// let payment_id = "pay_mbabizu24mvu3mela5njyhpit10".to_string();
// let customer_data = api::CreateCustomerRequest {
// customer_id: customer_id.clone(),
// merchant_id: merchant_id.clone(),
// ..api::CreateCustomerRequest::default()
// };
// let _customer = customer_data.insert(&state.pg_conn).unwrap();
// let merchant_account = services::authenticate(&state, "MySecretApiKey").unwrap();
// let payment_attempt = storage::PaymentAttempt::find_by_payment_id_merchant_id(
// &state.pg_conn,
// &payment_id,
// &merchant_id,
// )
// .unwrap();
// let payment_intent = storage::PaymentIntent::find_by_payment_id_merchant_id(
// &state.pg_conn,
// &payment_id,
// &merchant_id,
// )
// .unwrap();
// let payment_intent_update = storage::PaymentIntentUpdate::ReturnUrlUpdate {
// return_url: "http://example.com/payments".to_string(),
// status: None,
// };
// payment_intent
// .update(&state.pg_conn, payment_intent_update)
// .unwrap();
// let expected_response = services::ApplicationResponse::Form(services::RedirectForm {
// url: "http://example.com/payments".to_string(),
// method: services::Method::Post,
// form_fields: HashMap::from([("payment_id".to_string(), payment_id.clone())]),
// });
// let actual_response = payments_start_core(
// &state,
// merchant_account,
// api::PaymentsStartRequest {
// payment_id,
// merchant_id,
// txn_id: payment_attempt.txn_id.to_owned(),
// },
// )
// .await
// .unwrap();
// assert_eq!(expected_response, actual_response);
// }
#[cfg(feature = "v1")]
#[actix_rt::test]
#[ignore]
async fn payments_create_core_adyen_no_redirect() {
use hyperswitch_domain_models::merchant_context::{Context, MerchantContext};
use crate::configs::settings::Settings;
let conf = Settings::new().expect("invalid settings");
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
let payment_id =
id_type::PaymentId::try_from(Cow::Borrowed("pay_mbabizu24mvu3mela5njyhpit10")).unwrap();
let customer_id = format!("cust_{}", Uuid::new_v4());
let merchant_id = id_type::MerchantId::try_from(Cow::from("juspay_merchant")).unwrap();
let key_manager_state = &(&state).into();
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
key_manager_state,
&merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.unwrap();
let merchant_account = state
.store
.find_merchant_account_by_merchant_id(key_manager_state, &merchant_id, &key_store)
.await
.unwrap();
let merchant_context = MerchantContext::NormalMerchant(Box::new(Context(
merchant_account.clone(),
key_store.clone(),
)));
let req = api::PaymentsRequest {
payment_id: Some(api::PaymentIdType::PaymentIntentId(payment_id.clone())),
merchant_id: Some(merchant_id.clone()),
amount: Some(MinorUnit::new(6540).into()),
currency: Some(api_enums::Currency::USD),
capture_method: Some(api_enums::CaptureMethod::Automatic),
amount_to_capture: Some(MinorUnit::new(6540)),
capture_on: Some(datetime!(2022-09-10 10:11:12)),
confirm: Some(true),
customer_id: Some(id_type::CustomerId::try_from(Cow::from(customer_id)).unwrap()),
description: Some("Its my first payment request".to_string()),
return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
setup_future_usage: Some(api_enums::FutureUsage::OnSession),
authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
payment_method_data: Some(api::PaymentMethodDataRequest {
payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
card_number: "5555 3412 4444 1115".to_string().try_into().unwrap(),
card_exp_month: "03".to_string().into(),
card_exp_year: "2030".to_string().into(),
card_holder_name: Some(masking::Secret::new("JohnDoe".to_string())),
card_cvc: "737".to_string().into(),
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
nick_name: Some(masking::Secret::new("nick_name".into())),
})),
billing: None,
}),
payment_method: Some(api_enums::PaymentMethod::Card),
shipping: Some(api::Address {
address: None,
phone: None,
email: None,
}),
billing: Some(api::Address {
address: None,
phone: None,
email: None,
}),
statement_descriptor_name: Some("Juspay".to_string()),
statement_descriptor_suffix: Some("Router".to_string()),
..Default::default()
};
let expected_response = services::ApplicationResponse::JsonWithHeaders((
api::PaymentsResponse {
payment_id: payment_id.clone(),
status: api_enums::IntentStatus::Processing,
amount: MinorUnit::new(6540),
amount_capturable: MinorUnit::new(0),
amount_received: None,
client_secret: None,
created: None,
currency: "USD".to_string(),
customer_id: None,
description: Some("Its my first payment request".to_string()),
refunds: None,
mandate_id: None,
merchant_id,
net_amount: MinorUnit::new(6540),
connector: None,
customer: None,
disputes: None,
attempts: None,
captures: None,
mandate_data: None,
setup_future_usage: None,
off_session: None,
capture_on: None,
capture_method: None,
payment_method: None,
payment_method_data: None,
payment_token: None,
shipping: None,
billing: None,
order_details: None,
email: None,
name: None,
phone: None,
return_url: None,
authentication_type: None,
statement_descriptor_name: None,
statement_descriptor_suffix: None,
next_action: None,
cancellation_reason: None,
error_code: None,
error_message: None,
unified_code: None,
unified_message: None,
payment_experience: None,
payment_method_type: None,
connector_label: None,
business_country: None,
business_label: None,
business_sub_label: None,
allowed_payment_method_types: None,
ephemeral_key: None,
manual_retry_allowed: None,
connector_transaction_id: None,
frm_message: None,
metadata: None,
connector_metadata: None,
feature_metadata: None,
reference_id: None,
payment_link: None,
profile_id: None,
surcharge_details: None,
attempt_count: 1,
merchant_decision: None,
merchant_connector_id: None,
incremental_authorization_allowed: None,
authorization_count: None,
incremental_authorizations: None,
external_authentication_details: None,
external_3ds_authentication_attempted: None,
expires_on: None,
fingerprint: None,
browser_info: None,
mit_category: None,
payment_method_id: None,
payment_method_status: None,
updated: None,
split_payments: None,
frm_metadata: None,
merchant_order_reference_id: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_id: None,
shipping_cost: None,
card_discovery: None,
force_3ds_challenge: None,
force_3ds_challenge_trigger: None,
issuer_error_code: None,
issuer_error_message: None,
is_iframe_redirection_enabled: None,
whole_connector_response: None,
payment_channel: None,
network_transaction_id: None,
enable_partial_authorization: None,
is_overcapture_enabled: None,
enable_overcapture: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
vec![],
));
let actual_response = Box::pin(payments::payments_core::<
api::Authorize,
api::PaymentsResponse,
_,
_,
_,
payments::PaymentData<api::Authorize>,
>(
state.clone(),
state.get_req_state(),
merchant_context,
None,
payments::PaymentCreate,
req,
services::AuthFlow::Merchant,
payments::CallConnectorAction::Trigger,
None,
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await
.unwrap();
assert_eq!(expected_response, actual_response);
}
Reference in New Issue View Git Blame Copy Permalink