text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
// file: hyperswitch/crates/router/tests/connectors/nexinets.rs | crate: router | connector: nexinets | op: refund
use common_utils::types::MinorUnit;
use router::types::{self, domain, storage::enums, PaymentsAuthorizeData};
async fn should_refund_succeeded_payment_multiple_times() {
let captured_response = CONNECTOR
.make_payment(payment_method_details(), None)
.await
.unwrap();
assert_eq!(captured_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(captured_response.response.clone());
let connector_meta = utils::get_connector_metadata(captured_response.response);
for _x in 0..2 {
let refund_response = CONNECTOR
.refund_payment(
txn_id.clone().unwrap(),
Some(types::RefundsData {
connector_metadata: connector_meta.clone(),
connector_transaction_id: txn_id.clone().unwrap(),
refund_amount: 50,
currency: diesel_models::enums::Currency::EUR,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nexinets.rs | crate: router | connector: nexinets
use router::types::{self, domain, storage::enums, PaymentsAuthorizeData};
fn payment_method_details() -> Option<PaymentsAuthorizeData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/noon.rs | crate: router | connector: noon
use router::types::{self, storage::enums};
async fn should_fail_payment_for_incorrect_card_number() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/thunes.rs | crate: router | connector: thunes
use masking::Secret;
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/thunes.rs | crate: router | connector: thunes
use masking::Secret;
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/thunes.rs | crate: router | connector: thunes
use masking::Secret;
use crate::utils::{self, ConnectorActions};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Thunes;
api::ConnectorData {
connector: Box::new(Thunes::new()),
connector_name: types::Connector::Thunes,
get_token: types::api::GetToken::Connector,
merchant_connector_id: None,
}
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/amazonpay.rs | crate: router | connector: amazonpay
use router::types::{self, api, storage::enums};
fn get_name(&self) -> String {
"amazonpay".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/coinbase.rs | crate: router | connector: coinbase
use hyperswitch_domain_models::address::{Address, AddressDetails, PhoneDetails};
use masking::Secret;
use router::types::{self, api, domain, storage::enums, PaymentAddress};
use serde_json::json;
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("first".to_string())),
last_name: Some(Secret::new("last".to_string())),
line1: Some(Secret::new("line1".to_string())),
line2: Some(Secret::new("line2".to_string())),
city: Some("city".to_string()),
zip: Some(Secret::new("zip".to_string())),
country: Some(api_models::enums::CountryAlpha2::IN),
..Default::default()
}),
phone: Some(PhoneDetails {
number: Some(Secret::new("9123456789".to_string())),
country_code: Some("+91".to_string()),
}),
email: None,
}),
None,
None,
)),
connector_meta_data: Some(json!({"pricing_type": "fixed_price"})),
..Default::default()
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/coinbase.rs | crate: router | connector: coinbase | op: cancel
use router::types::{self, api, domain, storage::enums, PaymentAddress};
async fn should_sync_cancelled_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/coinbase.rs | crate: router | connector: coinbase | op: sync
use router::types::{self, api, domain, storage::enums, PaymentAddress};
async fn should_sync_expired_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/coinbase.rs | crate: router | connector: coinbase | op: sync
use router::types::{self, api, domain, storage::enums, PaymentAddress};
async fn should_sync_unresolved_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/coinbase.rs | crate: router | connector: coinbase
use router::types::{self, api, domain, storage::enums, PaymentAddress};
fn get_name(&self) -> String {
"coinbase".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/xendit.rs | crate: router | connector: xendit
use masking::Secret;
use router::{
types::{self, api, storage::enums,
}};
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/xendit.rs | crate: router | connector: xendit | op: authorize
use router::{
types::{self, api, storage::enums,
}};
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,);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nomupay.rs | crate: router | connector: nomupay | op: payout
use api_models::payments::{Address, AddressDetails};
use masking::Secret;
use router::types::{self, api, storage::enums, PaymentAddress};
fn get_payout_info() -> Option<PaymentInfo> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nomupay.rs | crate: router | connector: nomupay | op: payout
use router::types::{self, api, storage::enums, PaymentAddress};
async fn should_create_and_fulfill_bacs_payout() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nomupay.rs | crate: router | connector: nomupay | op: payout
use router::types::{self, api, storage::enums, PaymentAddress};
async fn should_create_payout_recipient() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nomupay.rs | crate: router | connector: nomupay
use router::types::{self, api, storage::enums, PaymentAddress};
use crate::utils::{self, ConnectorActions, PaymentInfo};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.nomupay
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/chargebee.rs | crate: router | connector: chargebee
use hyperswitch_domain_models::payment_method_data::{Card, PaymentMethodData};
use masking::Secret;
use router::types::{self, api, storage::enums};
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs | crate: router | connector: juspaythreedsserver | op: authorize
use router::types::{self, api, storage::enums};
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);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs | crate: router | connector: juspaythreedsserver
use router::types::{self, api, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.juspaythreedsserver
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs | crate: router | connector: juspaythreedsserver
fn new() -> Self {
Self
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cybersource.rs | crate: router | connector: cybersource | op: refund
use router::types::{self, api, domain, storage::enums};
async fn should_fail_refund_for_invalid_amount() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/cybersource.rs | crate: router | connector: cybersource | op: refund
use router::types::{self, api, domain, storage::enums};
async fn should_refund_succeeded_payment() {
let connector = Cybersource {};
let response = connector
.make_payment_and_refund(
get_default_payment_authorize_data(),
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Pending,
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cybersource.rs | crate: router | connector: cybersource | op: void
use router::types::{self, api, domain, storage::enums};
async fn should_fail_void_payment_for_reversed_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cybersource.rs | crate: router | connector: cybersource
use masking::Secret;
use router::types::{self, api, domain, storage::enums};
async fn should_fail_payment_for_invalid_exp_year() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cybersource.rs | crate: router | connector: cybersource | op: authorize
use router::types::{self, api, domain, storage::enums};
async fn should_partially_capture_already_authorized_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/dlocal.rs | crate: router | connector: dlocal
use hyperswitch_domain_models::address::{Address, AddressDetails};
use router::types::{self, api, domain, storage::enums, PaymentAddress};
pub fn get_payment_info() -> PaymentInfo {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/dlocal.rs | crate: router | connector: dlocal
use router::types::{self, api, domain, storage::enums, PaymentAddress};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.dlocal
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/datatrans.rs | crate: router | connector: datatrans
use router::types::{self, api, domain, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.datatrans
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/novalnet.rs | crate: router | connector: novalnet
use router::types::{self, api, storage::enums};
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/novalnet.rs | crate: router | connector: novalnet
use router::types::{self, api, storage::enums};
fn get_name(&self) -> String {
"novalnet".to_string()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cashtocode.rs | crate: router | connector: cashtocode | op: authorize
use router::types::{self, domain, storage::enums};
fn get_payment_authorize_data(
payment_method_type: Option<enums::PaymentMethodType>,
payment_method_data: domain::PaymentMethodData,
) -> Option<types::PaymentsAuthorizeData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cashtocode.rs | crate: router | connector: cashtocode
use router::types::{self, domain, storage::enums};
async fn should_fetch_pay_url_evoucher() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cashtocode.rs | crate: router | connector: cashtocode
use router::types::{self, domain, storage::enums};
async fn should_fetch_pay_url_classic() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/cashtocode.rs | crate: router | connector: cashtocode
use hyperswitch_domain_models::address::{Address, AddressDetails};
use router::types::{self, domain, storage::enums};
fn get_payment_info() -> Option<utils::PaymentInfo> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/bambora.rs | crate: router | connector: bambora | op: refund
use common_utils::types::MinorUnit;
use router::types::{self, domain, storage::enums};
async fn should_succeed_for_refund_amount_higher_than_payment_amount() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/bambora.rs | crate: router | connector: bambora | op: capture
use router::types::{self, domain, storage::enums};
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR
.make_payment(get_default_payment_authorize_data(), None)
.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, None)
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"Transaction cannot be adjusted"
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/bambora.rs | crate: router | connector: bambora | op: capture
use router::types::{self, domain, storage::enums};
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(get_default_payment_authorize_data(), None, None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/bambora.rs | crate: router | connector: bambora | op: authorize
use common_utils::types::MinorUnit;
use masking::Secret;
use router::types::{self, domain, storage::enums};
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte | op: refund
use std::{str::FromStr, time::Duration};
use common_utils::types::MinorUnit;
use router::types::{self, api, domain, storage::enums};
async fn should_sync_refund() {
let authorize_response = CONNECTOR
.make_payment(get_payment_data(), get_default_payment_info())
.await
.unwrap();
let txn_id = utils::get_connector_transaction_id(authorize_response.response.clone()).unwrap();
tokio::time::sleep(Duration::from_secs(10)).await;
let refund_connector_metadata = utils::get_connector_metadata(authorize_response.response);
let refund_response = CONNECTOR
.refund_payment(
txn_id,
Some(types::RefundsData {
connector_metadata: refund_connector_metadata,
..utils::PaymentRefundType::default().0
}),
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::Pending,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte | op: capture
use common_utils::types::MinorUnit;
use router::types::{self, api, domain, storage::enums};
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(get_payment_data(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Pending);
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(),
),
encoded_data: None,
capture_method: None,
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
//Status of the Payments is always in Pending State, Forte has to settle the sandbox transaction manually
assert_eq!(response.status, enums::AttemptStatus::Pending,);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte
use common_utils::types::MinorUnit;
use router::types::{self, api, domain, storage::enums};
async fn should_throw_not_implemented_for_unsupported_issuer() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte | op: authorize
use router::types::{self, api, domain, storage::enums};
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_data(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte
use common_utils::types::MinorUnit;
use router::types::{self, api, domain, storage::enums};
fn get_payment_data() -> Option<types::PaymentsAuthorizeData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/forte.rs | crate: router | connector: forte
use common_utils::types::MinorUnit;
use router::types::{self, api, domain, storage::enums};
use crate::{
connector_auth,
utils::{self, ConnectorActions},
};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.forte
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/jpmorgan.rs | crate: router | connector: jpmorgan | op: capture
use router::types::{self, api, storage::enums};
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,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/jpmorgan.rs | crate: router | connector: jpmorgan
use router::types::{self, api, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.jpmorgan
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payu.rs | crate: router | connector: payu | op: refund
async fn should_fail_already_refunded_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payu.rs | crate: router | connector: payu | op: refund
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
async fn should_sync_succeeded_refund_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payu.rs | crate: router | connector: payu
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
fn get_access_token() -> Option<AccessToken> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payu.rs | crate: router | connector: payu
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
use crate::{
connector_auth,
utils::{self, Connector, ConnectorActions, PaymentAuthorizeType},
};
fn get_auth_token(&self) -> ConnectorAuthType {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/paybox.rs | crate: router | connector: paybox
use masking::Secret;
use router::types::{self, api, domain, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Paybox;
utils::construct_connector_data_old(
Box::new(Paybox::new()),
types::Connector::Plaid,
api::GetToken::Connector,
None,
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/dummyconnector.rs | crate: router | connector: dummyconnector
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/paypal.rs | crate: router | connector: paypal | op: capture
use common_utils::types::MinorUnit;
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
async fn should_partially_refund_manually_captured_payment() {
let authorize_response = CONNECTOR
.authorize_payment(get_payment_data(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = "".to_string();
let capture_connector_meta = utils::get_connector_metadata(authorize_response.response);
let capture_response = CONNECTOR
.capture_payment(
txn_id,
Some(types::PaymentsCaptureData {
connector_meta: capture_connector_meta,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
let refund_txn_id =
utils::get_connector_transaction_id(capture_response.response.clone()).unwrap();
let response = CONNECTOR
.refund_payment(
refund_txn_id,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/paypal.rs | crate: router | connector: paypal
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(get_payment_data(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Pending);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/fiserv.rs | crate: router | connector: fiserv
use router::types::{self, domain, storage::enums};
use serde_json::json;
fn get_connector_meta(&self) -> Option<serde_json::Value> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/multisafepay.rs | crate: router | connector: multisafepay
use hyperswitch_domain_models::address::{Address, AddressDetails};
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentAddress};
fn get_default_payment_info() -> Option<PaymentInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/multisafepay.rs | crate: router | connector: multisafepay
use router::types::{self, domain, storage::enums, PaymentAddress};
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(None, get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/multisafepay.rs | crate: router | connector: multisafepay | op: authorize
use router::types::{self, domain, storage::enums, PaymentAddress};
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
None,
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);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/powertranz.rs | crate: router | connector: powertranz | op: capture
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("Original auth not found")
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/powertranz.rs | crate: router | connector: powertranz | op: refund
use router::types::{self, domain, storage::enums};
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/powertranz.rs | crate: router | connector: powertranz | op: authorize
use router::types::{self, domain, storage::enums};
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);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/deutschebank.rs | crate: router | connector: deutschebank | op: authorize
use router::types::{self, api, storage::enums};
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);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/bitpay.rs | crate: router | connector: bitpay
use router::types::{self, api, domain, storage::enums, PaymentAddress};
fn get_name(&self) -> String {
"bitpay".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/facilitapay.rs | crate: router | connector: facilitapay | op: refund
use router::types::{self, api, storage::enums};
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: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Refund amount (₹1.50) is greater than charge amount (₹1.00)",
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/facilitapay.rs | crate: router | connector: facilitapay | op: capture
use router::types::{self, api, storage::enums};
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,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/facilitapay.rs | crate: router | connector: facilitapay
use router::types::{self, api, storage::enums};
fn get_name(&self) -> String {
"facilitapay".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/plaid.rs | crate: router | connector: plaid
use masking::Secret;
use router::types::{self, api, domain, storage::enums};
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Invalid card cvc.".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/plaid.rs | crate: router | connector: plaid | op: authorize
use router::types::{self, api, domain, storage::enums};
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
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/plaid.rs | crate: router | connector: plaid
use router::types::{self, api, domain, storage::enums};
use crate::utils::{self, Connector, ConnectorActions};
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.plaid
.expect("Missing connector authentication configuration")
.into(),
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/plaid.rs | crate: router | connector: plaid
use masking::Secret;
use router::types::{self, api, domain, storage::enums};
use crate::utils::{self, Connector, ConnectorActions};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Plaid;
utils::construct_connector_data_old(
Box::new(Plaid::new()),
types::Connector::Plaid,
api::GetToken::Connector,
None,
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/mifinity.rs | crate: router | connector: mifinity
use router::types::{self, domain, storage::enums};
fn get_name(&self) -> String {
"mifinity".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/bankofamerica.rs | crate: router | connector: bankofamerica
use masking::Secret;
use router::types::{self, domain, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Bankofamerica;
utils::construct_connector_data_old(
Box::new(&Bankofamerica),
// Remove `dummy_connector` feature gate from module in `main.rs` when updating this to use actual connector variant
types::Connector::DummyConnector1,
types::api::GetToken::Connector,
None,
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/square.rs | crate: router | connector: square | op: refund
use router::types::{self, storage::enums, PaymentsResponseData};
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
None,
get_default_payment_info(create_token().await),
)
.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(None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/square.rs | crate: router | connector: square | op: capture
use router::types::{self, storage::enums, PaymentsResponseData};
async fn should_refund_auto_captured_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
None,
get_default_payment_info(create_token().await),
)
.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(None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/square.rs | crate: router | connector: square
use router::types::{self, storage::enums, PaymentsResponseData};
async fn create_token() -> Option<String> {
{
PaymentsResponseData::TokenizationResponse { token } => Some(token),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/square.rs | crate: router | connector: square
fn get_default_payment_info(payment_method_token: Option<String>) -> Option<utils::PaymentInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/redsys.rs | crate: router | connector: redsys
use masking::Secret;
use router::types::{self, api, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Redsys;
utils::construct_connector_data_old(
Box::new(Redsys::new()),
types::Connector::Plaid,
api::GetToken::Connector,
None,
)
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stripebilling.rs | crate: router | connector: stripebilling
use router::types::{self, api, storage::enums};
fn get_name(&self) -> String {
"stripebilling".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/globalpay.rs | crate: router | connector: globalpay | op: authorize
use router::types::{self, api, domain, storage::enums, AccessToken, ConnectorAuthType};
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(None, Globalpay::get_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()
}),
Globalpay::get_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/globalpay.rs | crate: router | connector: globalpay
use router::types::{self, api, domain, storage::enums, AccessToken, ConnectorAuthType};
fn get_name(&self) -> String {
"globalpay".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/airwallex.rs | crate: router | connector: airwallex | op: capture
use router::types::{self, domain, storage::enums, AccessToken};
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,
"The PaymentIntent status SUCCEEDED is invalid for operation cancel."
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stripe.rs | crate: router | connector: stripe | op: refund
use router::types::{self, domain, storage::enums};
async fn should_refund_succeeded_payment_multiple_times() {
let connector = Stripe {};
connector
.make_payment_and_multiple_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await;
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stripe.rs | crate: router | connector: stripe
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_invalid_card_cvc() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stripe.rs | crate: router | connector: stripe
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_invalid_exp_month() {
let response = Stripe {}
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_exp_month: Secret::new("13".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
None,
)
.await
.unwrap();
let x = response.response.unwrap_err();
assert_eq!(
x.reason.unwrap(),
"Your card's expiration month is invalid.",
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stripe.rs | crate: router | connector: stripe | op: authorize
use router::types::{self, domain, storage::enums};
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/rapyd.rs | crate: router | connector: rapyd | op: authorize
use router::types::{self, domain, storage::enums};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
async fn voiding_already_authorized_payment_fails() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/rapyd.rs | crate: router | connector: rapyd | op: authorize
use masking::Secret;
use router::types::{self, domain, storage::enums};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
async fn should_authorize_and_capture_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/shift4.rs | crate: router | connector: shift4 | op: capture
use router::types::{self, domain, storage::enums};
async fn should_partially_refund_manually_captured_payment() {
let connector = CONNECTOR;
let response = connector
.auth_capture_and_refund(
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/shift4.rs | crate: router | connector: shift4
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"The card's expiration month is invalid.".to_string(),
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/shift4.rs | crate: router | connector: shift4
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_succeed_payment_for_incorrect_cvc() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/shift4.rs | crate: router | connector: shift4 | op: authorize
use router::types::{self, domain, storage::enums};
async fn should_void_authorized_payment() {
let connector = CONNECTOR;
let response = connector
.authorize_and_void_payment(
None,
Some(types::PaymentsCancelData {
connector_transaction_id: "".to_string(),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
None,
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Pending); //shift4 doesn't allow voiding a payment
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/cryptopay.rs | crate: router | connector: cryptopay
use router::types::{self, api, domain, storage::enums, PaymentAddress};
fn get_name(&self) -> String {
"cryptopay".to_string()
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/checkout.rs | crate: router | connector: checkout
use masking::Secret;
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"card_expiry_month_invalid".to_string(),
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nmi.rs | crate: router | connector: nmi | op: capture
use router::types::{self, domain, storage::enums};
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 2023,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1023,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nmi.rs | crate: router | connector: nmi | op: authorize
use router::types::{self, domain, storage::enums};
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let void_response = CONNECTOR
.void_payment(
transaction_id.clone(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("user_cancel".to_string()),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(void_response.status, enums::AttemptStatus::VoidInitiated);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Voided,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Voided);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nmi.rs | crate: router | connector: nmi | op: authorize
use router::types::{self, domain, storage::enums};
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 1000,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nmi.rs | crate: router | connector: nmi
use router::types::{self, domain, storage::enums};
async fn should_make_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nmi.rs | crate: router | connector: nmi | op: authorize
use router::types::{self, domain, storage::enums};
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
// Assert the sync response, it will be authorized in case of manual capture, for automatic it will be Completed Success
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.