text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wellsfargo.rs<|crate|> router<|connector|> wellsfargo anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="229" end="229">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/noon.rs<|crate|> router<|connector|> noon anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="237" end="246">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="236" end="236">
use router::types::{self, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="250" end="266">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="210" end="233">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="200" end="206">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="45" end="50">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
currency: enums::Currency::AED,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/noon.rs" role="context" start="41" end="43">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/thunes.rs<|crate|> router<|connector|> thunes anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="215" end="224">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="228" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="191" end="211">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="184" end="187">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/amazonpay.rs<|crate|> router<|connector|> amazonpay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/payme.rs<|crate|> router<|connector|> payme anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="302" end="311">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="301" end="301">
use router::types::{self, domain, storage::enums, PaymentAddress};
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="334" end="345">
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;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="315" end="330">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="275" end="298">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="264" end="270">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="44" end="76">
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())),
}),
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,
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payme.rs" role="context" start="78" end="108">
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,
}]),
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
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/xendit.rs<|crate|> router<|connector|> xendit anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="215" end="224">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="214" end="214">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="228" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="191" end="211">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="184" end="187">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/boku.rs<|crate|> router<|connector|> boku anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/paystack.rs<|crate|> router<|connector|> paystack anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/inespay.rs<|crate|> router<|connector|> inespay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/chargebee.rs<|crate|> router<|connector|> chargebee anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/novalnet.rs<|crate|> router<|connector|> novalnet anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="229" end="229">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs<|crate|> router<|connector|> wellsfargopayout anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="229" end="229">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/coingate.rs<|crate|> router<|connector|> coingate anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="229" end="229">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/jpmorgan.rs<|crate|> router<|connector|> jpmorgan anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="237" end="246">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="236" end="236">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="250" end="266">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="210" end="233">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="200" end="206">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="44" end="46">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="48" end="50">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/paybox.rs<|crate|> router<|connector|> paybox anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="229" end="229">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs<|crate|> router<|connector|> unified_authentication_service anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/dummyconnector.rs<|crate|> router<|connector|> dummyconnector anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="233" end="242">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="232" end="232">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="266" end="277">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="246" end="262">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="206" end="229">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="196" end="202">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="40" end="42">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="44" end="46">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/paypal.rs<|crate|> router<|connector|> paypal anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="364" end="373">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(get_payment_data(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="363" end="363">
use router::types::{self, domain, storage::enums, AccessToken, ConnectorAuthType};
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="405" end="429">
async fn should_refund_succeeded_payment_multiple_times() {
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();
for _x in 0..2 {
let refund_response = CONNECTOR
.refund_payment(
txn_id.clone(),
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,
);
}
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="378" end="400">
async fn should_partially_refund_succeeded_payment() {
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();
let refund_response = CONNECTOR
.refund_payment(
txn_id,
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="323" end="359">
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.clone(),
enums::AttemptStatus::Pending
);
let txn_id = utils::get_connector_transaction_id(authorize_response.response.clone());
assert_ne!(txn_id, None, "Empty connector transaction id");
let connector_meta = utils::get_connector_metadata(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
mandate_id: None,
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
encoded_data: None,
capture_method: Some(enums::CaptureMethod::Automatic),
sync_type: types::SyncRequestType::SinglePaymentSync,
connector_meta,
payment_method_type: None,
currency: enums::Currency::USD,
payment_experience: None,
amount: MinorUnit::new(100),
integrity_object: None,
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="313" end="319">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="51" end="56">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
access_token: get_access_token(),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paypal.rs" role="context" start="58" end="66">
fn get_payment_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4000020000000000").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/globepay.rs<|crate|> router<|connector|> globepay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="232" end="241">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="231" end="231">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="265" end="276">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="245" end="261">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="205" end="228">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="195" end="201">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="43" end="45">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="39" end="41">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/powertranz.rs<|crate|> router<|connector|> powertranz anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="236" end="245">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="235" end="235">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="249" end="265">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="209" end="232">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="198" end="204">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="39" end="41">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="43" end="45">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/payone.rs<|crate|> router<|connector|> payone anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/razorpay.rs<|crate|> router<|connector|> razorpay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/deutschebank.rs<|crate|> router<|connector|> deutschebank anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/opayo.rs<|crate|> router<|connector|> opayo anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="235" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="234" end="234">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="268" end="279">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="248" end="264">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="208" end="231">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="198" end="204">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="46" end="48">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="42" end="44">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/getnet.rs<|crate|> router<|connector|> getnet anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/facilitapay.rs<|crate|> router<|connector|> facilitapay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/volt.rs<|crate|> router<|connector|> volt anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/fiuu.rs<|crate|> router<|connector|> fiuu anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/hipay.rs<|crate|> router<|connector|> hipay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/digitalvirgo.rs<|crate|> router<|connector|> digitalvirgo anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="215" end="224">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="214" end="214">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="228" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="191" end="211">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="184" end="187">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/plaid.rs<|crate|> router<|connector|> plaid anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="230" end="230">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/mifinity.rs<|crate|> router<|connector|> mifinity anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bankofamerica.rs<|crate|> router<|connector|> bankofamerica anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="230" end="230">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/redsys.rs<|crate|> router<|connector|> redsys anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripebilling.rs<|crate|> router<|connector|> stripebilling anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/gocardless.rs<|crate|> router<|connector|> gocardless anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/airwallex.rs<|crate|> router<|connector|> airwallex anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="293" end="302">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="292" end="292">
use router::types::{self, domain, storage::enums, AccessToken};
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="330" end="341">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="308" end="324">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="265" end="287">
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(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="254" end="260">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="52" end="71">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
access_token: get_access_token(),
address: Some(types::PaymentAddress::new(
None,
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("John".to_string())),
last_name: Some(Secret::new("Doe".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="72" end="92">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4035501000000008").unwrap(),
card_exp_month: Secret::new("02".to_string()),
card_exp_year: Secret::new("2035".to_string()),
card_cvc: Secret::new("123".to_string()),
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
nick_name: Some(Secret::new("nick_name".into())),
card_holder_name: Some(Secret::new("card holder name".into())),
}),
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
router_return_url: Some("https://google.com".to_string()),
complete_authorize_url: Some("https://google.com".to_string()),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/checkout.rs<|crate|> router<|connector|> checkout anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="242" end="251">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="241" end="241">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="277" end="288">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="256" end="272">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="214" end="237">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="203" end="209">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/billwerk.rs<|crate|> router<|connector|> billwerk anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="230" end="230">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/ebanx.rs<|crate|> router<|connector|> ebanx anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="229" end="229">
use router::types::{self, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/ebanx.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/elavon.rs<|crate|> router<|connector|> elavon anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="237" end="246">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="236" end="236">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="250" end="266">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="210" end="233">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="200" end="206">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="48" end="50">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/elavon.rs" role="context" start="44" end="46">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/taxjar.rs<|crate|> router<|connector|> taxjar anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="229" end="229">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/taxjar.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/fiservemea.rs<|crate|> router<|connector|> fiservemea anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiservemea.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/placetopay.rs<|crate|> router<|connector|> placetopay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="229" end="229">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/placetopay.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bamboraapac.rs<|crate|> router<|connector|> bamboraapac anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="229" end="229">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="203" end="226">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="193" end="199">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bamboraapac.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/moneris.rs<|crate|> router<|connector|> moneris anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/moneris.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nexixpay.rs<|crate|> router<|connector|> nexixpay anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="230" end="230">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="204" end="227">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="194" end="200">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nexixpay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/src/utils/user/theme.rs<|crate|> router anchor=validate_merchant kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="138" end="146">
async fn validate_merchant(
state: &SessionState,
org_id: &id_type::OrganizationId,
merchant_id: &id_type::MerchantId,
) -> UserResult<()> {
validate_merchant_and_get_key_store(state, org_id, merchant_id)
.await
.map(|_| ())
}
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="137" end="137">
use common_utils::{ext_traits::AsyncExt, id_type, types::theme::ThemeLineage};
use crate::{
core::errors::{StorageErrorExt, UserErrors, UserResult},
routes::SessionState,
services::authentication::UserFromToken,
};
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="167" end="186">
pub async fn get_most_specific_theme_using_token_and_min_entity(
state: &SessionState,
user_from_token: &UserFromToken,
min_entity: EntityType,
) -> UserResult<Option<Theme>> {
get_most_specific_theme_using_lineage(
state,
ThemeLineage::new(
min_entity,
user_from_token
.tenant_id
.clone()
.unwrap_or(state.tenant.tenant_id.clone()),
user_from_token.org_id.clone(),
user_from_token.merchant_id.clone(),
user_from_token.profile_id.clone(),
),
)
.await
}
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="148" end="165">
async fn validate_profile(
state: &SessionState,
profile_id: &id_type::ProfileId,
merchant_id: &id_type::MerchantId,
key_store: &MerchantKeyStore,
) -> UserResult<()> {
state
.store
.find_business_profile_by_merchant_id_profile_id(
&state.into(),
key_store,
merchant_id,
profile_id,
)
.await
.to_not_found_response(UserErrors::InvalidThemeLineage("profile_id".to_string()))
.map(|_| ())
}
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="110" end="136">
async fn validate_merchant_and_get_key_store(
state: &SessionState,
org_id: &id_type::OrganizationId,
merchant_id: &id_type::MerchantId,
) -> UserResult<MerchantKeyStore> {
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
&state.into(),
merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.to_not_found_response(UserErrors::InvalidThemeLineage("merchant_id".to_string()))?;
let merchant_account = state
.store
.find_merchant_account_by_merchant_id(&state.into(), merchant_id, &key_store)
.await
.to_not_found_response(UserErrors::InvalidThemeLineage("merchant_id".to_string()))?;
if &merchant_account.organization_id != org_id {
return Err(UserErrors::InvalidThemeLineage("merchant_id".to_string()).into());
}
Ok(key_store)
}
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="101" end="108">
async fn validate_org(state: &SessionState, org_id: &id_type::OrganizationId) -> UserResult<()> {
state
.accounts_store
.find_organization_by_org_id(org_id)
.await
.to_not_found_response(UserErrors::InvalidThemeLineage("org_id".to_string()))
.map(|_| ())
}
<file_sep path="hyperswitch/crates/router/src/utils/user/theme.rs" role="context" start="58" end="92">
pub async fn validate_lineage(state: &SessionState, lineage: &ThemeLineage) -> UserResult<()> {
match lineage {
ThemeLineage::Tenant { tenant_id } => {
validate_tenant(state, tenant_id)?;
Ok(())
}
ThemeLineage::Organization { tenant_id, org_id } => {
validate_tenant(state, tenant_id)?;
validate_org(state, org_id).await?;
Ok(())
}
ThemeLineage::Merchant {
tenant_id,
org_id,
merchant_id,
} => {
validate_tenant(state, tenant_id)?;
validate_org(state, org_id).await?;
validate_merchant(state, org_id, merchant_id).await?;
Ok(())
}
ThemeLineage::Profile {
tenant_id,
org_id,
merchant_id,
profile_id,
} => {
validate_tenant(state, tenant_id)?;
validate_org(state, org_id).await?;
let key_store = validate_merchant_and_get_key_store(state, org_id, merchant_id).await?;
validate_profile(state, profile_id, merchant_id, &key_store).await?;
Ok(())
}
}
}
<file_sep path="hyperswitch/crates/router/tests/utils.rs" role="context" start="389" end="391">
pub struct MerchantId {
merchant_id: common_utils::id_type::MerchantId,
}
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/src/types/domain/user.rs<|crate|> router anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="269" end="275">
fn try_from(value: user_api::SignUpWithMerchantIdRequest) -> UserResult<Self> {
let new_organization = api_org::OrganizationNew::new(Some(
UserCompanyName::new(value.company_name)?.get_secret(),
));
let db_organization = ForeignFrom::foreign_from(new_organization);
Ok(Self(db_organization))
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="268" end="268">
use api_models::{
admin as admin_api, organization as api_org, user as user_api, user_role as user_role_api,
};
use crate::{
consts,
core::{
admin,
errors::{UserErrors, UserResult},
},
db::GlobalStorageInterface,
routes::SessionState,
services::{self, authentication::UserFromToken},
types::{domain, transformers::ForeignFrom},
utils::user::password,
};
type InviteeUserRequestWithInvitedUserToken = (user_api::InviteUserRequest, UserFromToken);
type UserMerchantCreateRequestWithToken =
(UserFromStorage, user_api::UserMerchantCreate, UserFromToken);
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="287" end="291">
fn from(_value: user_api::ConnectAccountRequest) -> Self {
let new_organization = api_org::OrganizationNew::new(None);
let db_organization = ForeignFrom::foreign_from(new_organization);
Self(db_organization)
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="279" end="283">
fn from(_value: user_api::SignUpRequest) -> Self {
let new_organization = api_org::OrganizationNew::new(None);
let db_organization = ForeignFrom::foreign_from(new_organization);
Self(db_organization)
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="262" end="264">
pub fn get_organization_id(&self) -> id_type::OrganizationId {
self.0.get_organization_id()
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="247" end="260">
pub async fn insert_org_in_db(self, state: SessionState) -> UserResult<Organization> {
state
.accounts_store
.insert_organization(self.0)
.await
.map_err(|e| {
if e.current_context().is_db_unique_violation() {
e.change_context(UserErrors::DuplicateOrganizationId)
} else {
e.change_context(UserErrors::InternalServerError)
}
})
.attach_printable("Error while inserting organization")
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="1256" end="1265">
pub fn new(name: String) -> UserResult<Self> {
let is_empty_or_whitespace = name.trim().is_empty();
let is_too_long = name.graphemes(true).count() > consts::user_role::MAX_ROLE_NAME_LENGTH;
if is_empty_or_whitespace || is_too_long || name.contains(' ') {
Err(UserErrors::RoleNameParsingError.into())
} else {
Ok(Self(name.to_lowercase()))
}
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="1244" end="1249">
fn foreign_from(value: UserStatus) -> Self {
match value {
UserStatus::Active => Self::Active,
UserStatus::InvitationSent => Self::InvitationSent,
}
}
<file_sep path="hyperswitch/crates/router/src/types/domain/user.rs" role="context" start="219" end="219">
pub struct UserCompanyName(String);
<file_sep path="hyperswitch/crates/router/src/core/errors/user.rs" role="context" start="5" end="5">
pub type UserResult<T> = CustomResult<T, UserErrors>;
<file_sep path="hyperswitch/crates/api_models/src/organization.rs" role="context" start="3" end="6">
pub struct OrganizationNew {
pub org_id: id_type::OrganizationId,
pub org_name: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/thunes.rs<|crate|> router<|connector|> thunes anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="128" end="137">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="162" end="180">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="110" end="124">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="86" end="106">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/xendit.rs<|crate|> router<|connector|> xendit anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="128" end="137">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="127" end="127">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="162" end="180">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="110" end="124">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="86" end="106">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/cybersource.rs<|crate|> router<|connector|> cybersource anchor=should_capture_already_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="94" end="104">
async fn should_capture_already_authorized_payment() {
let connector = Cybersource {};
let response = connector
.authorize_and_capture_payment(
get_default_payment_authorize_data(),
None,
get_default_payment_info(),
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="93" end="93">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="123" end="139">
async fn should_sync_payment() {
let connector = Cybersource {};
let response = connector
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"6699597903496176903954".to_string(),
),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="106" end="119">
async fn should_partially_capture_already_authorized_payment() {
let connector = Cybersource {};
let response = connector
.authorize_and_capture_payment(
get_default_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="83" end="92">
async fn should_make_payment() {
let response = Cybersource {}
.make_payment(
get_default_payment_authorize_data(),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="72" end="81">
async fn should_only_authorize_payment() {
let response = Cybersource {}
.authorize_payment(
get_default_payment_authorize_data(),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="37" end="63">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(types::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,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="64" end="70">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
currency: enums::Currency::USD,
email: Some(Email::from_str("abc@gmail.com").unwrap()),
..PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/cybersource.rs" role="context" start="12" end="12">
struct Cybersource;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/digitalvirgo.rs<|crate|> router<|connector|> digitalvirgo anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="128" end="137">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="127" end="127">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="162" end="180">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="110" end="124">
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="86" end="106">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/digitalvirgo.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/globalpay.rs<|crate|> router<|connector|> globalpay anchor=get_access_token kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="45" end="53">
fn get_access_token() -> Option<AccessToken> {
match Connector::get_auth_token(&CONNECTOR) {
ConnectorAuthType::BodyKey { api_key, key1: _ } => Some(AccessToken {
token: api_key,
expires: 18600,
}),
_ => None,
}
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="44" end="44">
use router::types::{self, api, domain, storage::enums, AccessToken, ConnectorAuthType};
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="59" end="78">
fn get_payment_info() -> Option<PaymentInfo> {
Some(PaymentInfo {
address: Some(types::PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
country: Some(api_models::enums::CountryAlpha2::US),
..Default::default()
}),
phone: None,
..Default::default()
}),
None,
None,
)),
access_token: get_access_token(),
connector_meta_data: CONNECTOR.get_connector_meta(),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="56" end="58">
fn get_request_interval(&self) -> u64 {
5
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="40" end="42">
fn get_connector_meta(&self) -> Option<serde_json::Value> {
Some(json!({"account_name": "transaction_processing"}))
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="36" end="38">
fn get_name(&self) -> String {
"globalpay".to_string()
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globalpay.rs" role="context" start="27" end="34">
fn get_auth_token(&self) -> ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.globalpay
.expect("Missing connector authentication configuration")
.into(),
)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="24" end="44">
pub trait Connector {
fn get_data(&self) -> types::api::ConnectorData;
fn get_auth_token(&self) -> types::ConnectorAuthType;
fn get_name(&self) -> String;
fn get_connector_meta(&self) -> Option<serde_json::Value> {
None
}
/// interval in seconds to be followed when making the subsequent request whenever needed
fn get_request_interval(&self) -> u64 {
5
}
#[cfg(feature = "payouts")]
fn get_payout_data(&self) -> Option<types::api::ConnectorData> {
None
}
}
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="1017" end="1046">
pub enum ConnectorAuthType {
TemporaryAuth,
HeaderKey {
api_key: Secret<String>,
},
BodyKey {
api_key: Secret<String>,
key1: Secret<String>,
},
SignatureKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
},
MultiAuthKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
key2: Secret<String>,
},
CurrencyAuthKey {
auth_key_map: HashMap<common_enums::Currency, pii::SecretSerdeValue>,
},
CertificateAuth {
certificate: Secret<String>,
private_key: Secret<String>,
},
#[default]
NoKey,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/tsys.rs<|crate|> router<|connector|> tsys anchor=should_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="70" end="80">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(100),
None,
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="69" end="69">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="101" end="121">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(140), 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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="84" end="97">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(130),
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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="60" end="66">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(101), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="46" end="55">
fn payment_method_details(amount: i64) -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
amount,
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/tsys.rs" role="context" start="42" end="44">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/src/services/encryption.rs<|crate|> router anchor=test_jws kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/src/services/encryption.rs" role="context" start="238" end="244">
async fn test_jws() {
let jwt = jws_sign_payload("jws payload".as_bytes(), "1", SIGNING_KEY)
.await
.unwrap();
let payload = verify_sign(jwt, SIGNATURE_VERIFICATION_KEY).unwrap();
assert_eq!("jws payload".to_string(), payload)
}
<file_sep path="hyperswitch/crates/router/src/services/encryption.rs" role="context" start="237" end="237">
use josekit::{jwe, jws};
<file_sep path="hyperswitch/crates/router/src/services/encryption.rs" role="context" start="221" end="235">
async fn test_jwe() {
let jwt = encrypt_jwe(
"request_payload".as_bytes(),
ENCRYPTION_KEY,
EncryptionAlgorithm::A256GCM,
None,
)
.await
.unwrap();
let alg = jwe::RSA_OAEP_256;
let payload = decrypt_jwe(&jwt, KeyIdCheck::SkipKeyIdCheck, DECRYPTION_KEY, alg)
.await
.unwrap();
assert_eq!("request_payload".to_string(), payload)
}
<file_sep path="hyperswitch/crates/router/src/services/encryption.rs" role="context" start="109" end="126">
pub fn verify_sign(
jws_body: String,
key: impl AsRef<[u8]>,
) -> CustomResult<String, errors::EncryptionError> {
let alg = jws::RS256;
let input = jws_body.as_bytes();
let verifier = alg
.verifier_from_pem(key)
.change_context(errors::EncryptionError)
.attach_printable("Error getting verifier")?;
let (dst_payload, _dst_header) = jws::deserialize_compact(input, &verifier)
.change_context(errors::EncryptionError)
.attach_printable("Error getting Decrypted jws")?;
let resp = String::from_utf8(dst_payload)
.change_context(errors::EncryptionError)
.attach_printable("Could not convert to UTF-8")?;
Ok(resp)
}
<file_sep path="hyperswitch/crates/router/src/services/encryption.rs" role="context" start="91" end="107">
pub async fn jws_sign_payload(
payload: &[u8],
kid: &str,
private_key: impl AsRef<[u8]>,
) -> CustomResult<String, errors::EncryptionError> {
let alg = jws::RS256;
let mut src_header = jws::JwsHeader::new();
src_header.set_key_id(kid);
let signer = alg
.signer_from_pem(private_key)
.change_context(errors::EncryptionError)
.attach_printable("Error getting signer")?;
let jwt = jws::serialize_compact(payload, &src_header, &signer)
.change_context(errors::EncryptionError)
.attach_printable("Error getting signed jwt string")?;
Ok(jwt)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/src/services/authentication.rs<|crate|> router anchor=get_cookie_from_header kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3856" end="3864">
pub fn get_cookie_from_header(headers: &HeaderMap) -> RouterResult<&str> {
let cookie = headers
.get(cookies::get_cookie_header())
.ok_or(report!(errors::ApiErrorResponse::CookieNotFound))?;
cookie
.to_str()
.change_context(errors::ApiErrorResponse::InvalidCookie)
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3855" end="3855">
use std::str::FromStr;
use actix_web::http::header::HeaderMap;
use error_stack::{report, ResultExt};
use crate::core::errors::UserResult;
use crate::{
core::{
api_keys,
errors::{self, utils::StorageErrorExt, RouterResult},
},
headers,
routes::app::SessionStateInfo,
services::api,
types::{domain, storage},
utils::OptionExt,
};
pub type AuthenticationDataWithUserId = (AuthenticationData, String);
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3872" end="3883">
pub fn auth_type<'a, T, A>(
default_auth: &'a dyn AuthenticateAndFetch<T, A>,
jwt_auth_type: &'a dyn AuthenticateAndFetch<T, A>,
headers: &HeaderMap,
) -> &'a dyn AuthenticateAndFetch<T, A>
where
{
if is_jwt_auth(headers) {
return jwt_auth_type;
}
default_auth
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3866" end="3870">
pub fn strip_jwt_token(token: &str) -> RouterResult<&str> {
token
.strip_prefix("Bearer ")
.ok_or_else(|| errors::ApiErrorResponse::InvalidJwtToken.into())
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3845" end="3854">
pub fn get_jwt_from_authorization_header(headers: &HeaderMap) -> RouterResult<&str> {
headers
.get(headers::AUTHORIZATION)
.get_required_value(headers::AUTHORIZATION)?
.to_str()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to convert JWT token to string")?
.strip_prefix("Bearer ")
.ok_or(errors::ApiErrorResponse::InvalidJwtToken.into())
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3830" end="3843">
pub fn get_id_type_by_key_from_headers<T: FromStr>(
key: String,
headers: &HeaderMap,
) -> RouterResult<Option<T>> {
get_header_value_by_key(key.clone(), headers)?
.map(|str_value| T::from_str(str_value))
.transpose()
.map_err(|_err| {
error_stack::report!(errors::ApiErrorResponse::InvalidDataFormat {
field_name: key,
expected_format: "Valid Id String".to_string(),
})
})
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3789" end="3797">
pub fn is_jwt_auth(headers: &HeaderMap) -> bool {
let header_map_struct = HeaderMapStruct::new(headers);
match header_map_struct.get_auth_string_from_header() {
Ok(auth_str) => auth_str.starts_with("Bearer"),
Err(_) => get_cookie_from_header(headers)
.and_then(cookies::get_jwt_from_cookies)
.is_ok(),
}
}
<file_sep path="hyperswitch/crates/router/src/services/authentication.rs" role="context" start="3267" end="3294">
pub async fn parse_jwt_payload<A, T>(headers: &HeaderMap, state: &A) -> RouterResult<T>
where
T: serde::de::DeserializeOwned,
A: SessionStateInfo + Sync,
{
let cookie_token_result =
get_cookie_from_header(headers).and_then(cookies::get_jwt_from_cookies);
let auth_header_token_result = get_jwt_from_authorization_header(headers);
let force_cookie = state.conf().user.force_cookies;
logger::info!(
user_agent = ?headers.get(headers::USER_AGENT),
header_names = ?headers.keys().collect::<Vec<_>>(),
is_token_equal =
auth_header_token_result.as_deref().ok() == cookie_token_result.as_deref().ok(),
cookie_error = ?cookie_token_result.as_ref().err(),
token_error = ?auth_header_token_result.as_ref().err(),
force_cookie,
);
let final_token = if force_cookie {
cookie_token_result?
} else {
auth_header_token_result?.to_owned()
};
decode_jwt(&final_token, state).await
}
<file_sep path="hyperswitch/crates/router/src/core/errors.rs" role="context" start="31" end="31">
pub type RouterResult<T> = CustomResult<T, ApiErrorResponse>;
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="86" end="100">
pub enum ApiErrorResponse {
Unauthorized(ApiError),
ForbiddenCommonResource(ApiError),
ForbiddenPrivateResource(ApiError),
Conflict(ApiError),
Gone(ApiError),
Unprocessable(ApiError),
InternalServerError(ApiError),
NotImplemented(ApiError),
ConnectorError(ApiError, #[serde(skip_serializing)] StatusCode),
NotFound(ApiError),
MethodNotAllowed(ApiError),
BadRequest(ApiError),
DomainError(ApiError),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/forte.rs<|crate|> router<|connector|> forte anchor=should_make_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="306" end="313">
async fn should_make_payment() {
let response = CONNECTOR
.make_payment(get_payment_data(), 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);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="305" end="305">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="347" end="370">
async fn should_refund_auto_captured_payment() {
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 response = CONNECTOR
.refund_payment(
txn_id,
Some(types::RefundsData {
connector_metadata: refund_connector_metadata,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Pending,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="317" end="342">
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,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="284" end="302">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(None, 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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="244" end="279">
async fn should_partially_refund_manually_captured_payment() {
let authorize_response = CONNECTOR
.authorize_payment(get_payment_data(), None)
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response.clone()).unwrap();
let capture_connector_meta = utils::get_connector_metadata(authorize_response.response);
let capture_response = CONNECTOR
.capture_payment(
txn_id.clone(),
Some(types::PaymentsCaptureData {
connector_meta: capture_connector_meta,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.expect("Capture payment response");
let refund_connector_metadata = utils::get_connector_metadata(capture_response.response);
let response = CONNECTOR
.refund_payment(
txn_id,
Some(types::RefundsData {
connector_metadata: refund_connector_metadata,
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="44" end="52">
fn get_payment_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/forte.rs" role="context" start="54" end="80">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(types::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,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/src/core/cards_info.rs" role="context" start="157" end="157">
pub trait State {}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wellsfargo.rs<|crate|> router<|connector|> wellsfargo anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="262" end="262">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargo.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/thunes.rs<|crate|> router<|connector|> thunes anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="286" end="304">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="263" end="281">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="228" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="215" end="224">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/thunes.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/amazonpay.rs<|crate|> router<|connector|> amazonpay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/amazonpay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/xendit.rs<|crate|> router<|connector|> xendit anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="247" end="247">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="286" end="304">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="263" end="281">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="228" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="215" end="224">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/xendit.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/boku.rs<|crate|> router<|connector|> boku anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/boku.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/paystack.rs<|crate|> router<|connector|> paystack anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paystack.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/inespay.rs<|crate|> router<|connector|> inespay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/inespay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/chargebee.rs<|crate|> router<|connector|> chargebee anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/chargebee.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs<|crate|> router<|connector|> juspaythreedsserver anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="269" end="269">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="285" end="303">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="250" end="266">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="237" end="246">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="48" end="50">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/juspaythreedsserver.rs" role="context" start="44" end="46">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/datatrans.rs<|crate|> router<|connector|> datatrans anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="262" end="262">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/datatrans.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/netcetera.rs<|crate|> router<|connector|> netcetera anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="262" end="273">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="261" end="261">
use router::types::{self, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="299" end="315">
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,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="277" end="295">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="242" end="258">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="229" end="238">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="36" end="38">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/netcetera.rs" role="context" start="40" end="42">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/novalnet.rs<|crate|> router<|connector|> novalnet anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="262" end="262">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="301" end="319">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/novalnet.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/prophetpay.rs<|crate|> router<|connector|> prophetpay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/prophetpay.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs<|crate|> router<|connector|> wellsfargopayout anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="262" end="262">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/wellsfargopayout.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/coingate.rs<|crate|> router<|connector|> coingate anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="262" end="262">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coingate.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/jpmorgan.rs<|crate|> router<|connector|> jpmorgan anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="269" end="269">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="285" end="303">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="250" end="266">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="237" end="246">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="48" end="50">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/jpmorgan.rs" role="context" start="44" end="46">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/paybox.rs<|crate|> router<|connector|> paybox anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="262" end="262">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/paybox.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs<|crate|> router<|connector|> unified_authentication_service anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/unified_authentication_service.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/dummyconnector.rs<|crate|> router<|connector|> dummyconnector anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="266" end="277">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="265" end="265">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="304" end="322">
async fn should_fail_payment_for_incorrect_card_number() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: CardNumber::from_str("1234567891011").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card number is incorrect.".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="281" end="299">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="246" end="262">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="233" end="242">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="44" end="46">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/dummyconnector.rs" role="context" start="40" end="42">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/globepay.rs<|crate|> router<|connector|> globepay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="265" end="276">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="264" end="264">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="303" end="321">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="280" end="298">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="245" end="261">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="232" end="241">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="43" end="45">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/globepay.rs" role="context" start="39" end="41">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/fiserv.rs<|crate|> router<|connector|> fiserv anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="306" end="317">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="305" end="305">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="347" end="365">
async fn should_fail_payment_for_incorrect_card_number() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("1234567891011").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Unable to assign card to brand: Invalid.".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="322" end="341">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
tokio::time::sleep(std::time::Duration::from_secs(7)).await;
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="285" end="301">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="271" end="280">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="43" end="61">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4005550000000019").unwrap(),
card_exp_month: Secret::new("02".to_string()),
card_exp_year: Secret::new("2035".to_string()),
card_cvc: Secret::new("123".to_string()),
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
nick_name: Some(Secret::new("nick_name".into())),
card_holder_name: Some(Secret::new("card holder name".into())),
}),
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiserv.rs" role="context" start="63" end="68">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
connector_meta_data: Some(json!({"terminalId": "10000001"})),
..utils::PaymentInfo::with_default_billing_name()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/powertranz.rs<|crate|> router<|connector|> powertranz anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="270" end="281">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="269" end="269">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="309" end="327">
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,
"Field is invalid: CardCvv".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="286" end="304">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="249" end="265">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="236" end="245">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="43" end="45">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/powertranz.rs" role="context" start="39" end="41">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/payone.rs<|crate|> router<|connector|> payone anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payone.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/razorpay.rs<|crate|> router<|connector|> razorpay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/razorpay.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/deutschebank.rs<|crate|> router<|connector|> deutschebank anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/deutschebank.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/opayo.rs<|crate|> router<|connector|> opayo anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="268" end="279">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="267" end="267">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="306" end="324">
async fn should_fail_payment_for_incorrect_card_number() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("1234567891011").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card number is incorrect.".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="283" end="301">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="248" end="264">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="235" end="244">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="46" end="48">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/opayo.rs" role="context" start="42" end="44">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/getnet.rs<|crate|> router<|connector|> getnet anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/getnet.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/facilitapay.rs<|crate|> router<|connector|> facilitapay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/facilitapay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/volt.rs<|crate|> router<|connector|> volt anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/volt.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/fiuu.rs<|crate|> router<|connector|> fiuu anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/fiuu.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/hipay.rs<|crate|> router<|connector|> hipay anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/hipay.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/itaubank.rs<|crate|> router<|connector|> itaubank anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="262" end="262">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/itaubank.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/helcim.rs<|crate|> router<|connector|> helcim anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/helcim.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/plaid.rs<|crate|> router<|connector|> plaid anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="263" end="263">
use router::types::{self, api, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="302" end="320">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/plaid.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/mifinity.rs<|crate|> router<|connector|> mifinity anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/mifinity.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bankofamerica.rs<|crate|> router<|connector|> bankofamerica anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="263" end="263">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="302" end="320">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bankofamerica.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/redsys.rs<|crate|> router<|connector|> redsys anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/redsys.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripebilling.rs<|crate|> router<|connector|> stripebilling anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="263" end="263">
use router::types::{self, api, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="302" end="320">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripebilling.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/gocardless.rs<|crate|> router<|connector|> gocardless anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="263" end="274">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="262" end="262">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="301" end="319">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="278" end="296">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="243" end="259">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="230" end="239">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="37" end="39">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/gocardless.rs" role="context" start="41" end="43">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/airwallex.rs<|crate|> router<|connector|> airwallex anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="330" end="341">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="329" end="329">
use router::types::{self, domain, storage::enums, AccessToken};
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="371" end="389">
async fn should_fail_payment_for_incorrect_card_number() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("1234567891011").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Invalid card number".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="347" end="365">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="308" end="324">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="293" end="302">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="52" end="71">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
access_token: get_access_token(),
address: Some(types::PaymentAddress::new(
None,
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("John".to_string())),
last_name: Some(Secret::new("Doe".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/airwallex.rs" role="context" start="72" end="92">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4035501000000008").unwrap(),
card_exp_month: Secret::new("02".to_string()),
card_exp_year: Secret::new("2035".to_string()),
card_cvc: Secret::new("123".to_string()),
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
nick_name: Some(Secret::new("nick_name".into())),
card_holder_name: Some(Secret::new("card holder name".into())),
}),
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
router_return_url: Some("https://google.com".to_string()),
complete_authorize_url: Some("https://google.com".to_string()),
..utils::PaymentAuthorizeType::default().0
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/checkout.rs<|crate|> router<|connector|> checkout anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="277" end="288">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="276" end="276">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="319" end="337">
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,
"cvv_invalid".to_string(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="293" end="312">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="256" end="272">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="242" end="251">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/checkout.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/billwerk.rs<|crate|> router<|connector|> billwerk anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="264" end="275">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="263" end="263">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="302" end="320">
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(),
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="279" end="297">
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().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="244" end="260">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="231" end="240">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/crates/router/tests/connectors/billwerk.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.