id
stringlengths 20
153
| type
stringclasses 1
value | granularity
stringclasses 14
values | content
stringlengths 16
84.3k
| metadata
dict |
|---|---|---|---|---|
connector-service_snippet_5183309079052678393_100_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Generate random billing address to avoid duplicates
let mut rng = rand::thread_rng();
let random_street_num = rng.gen_range(100..9999);
let random_zip_suffix = rng.gen_range(1000..9999);
let address = PaymentAddress {
billing_address: Some(Address {
first_name: Some("John".to_string().into()),
last_name: Some("Doe".to_string().into()),
email: Some(TEST_EMAIL.to_string().into()),
line1: Some(format!("{} Main St", random_street_num).into()),
city: Some("San Francisco".to_string().into()),
state: Some("CA".to_string().into()),
zip_code: Some(format!("{}", random_zip_suffix).into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
..Default::default()
}),
shipping_address: None,
};
// Use random amount to avoid duplicates
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_100_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Generate random billing address to avoid duplicates
let mut rng = rand::thread_rng();
let random_street_num = rng.gen_range(100..9999);
let random_zip_suffix = rng.gen_range(1000..9999);
let address = PaymentAddress {
billing_address: Some(Address {
first_name: Some("John".to_string().into()),
last_name: Some("Doe".to_string().into()),
email: Some(TEST_EMAIL.to_string().into()),
line1: Some(format!("{} Main St", random_street_num).into()),
city: Some("San Francisco".to_string().into()),
state: Some("CA".to_string().into()),
zip_code: Some(format!("{}", random_zip_suffix).into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
..Default::default()
}),
shipping_address: None,
};
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
PaymentServiceAuthorizeRequest {
amount: unique_amount,
minor_amount: unique_amount,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
return_url: Some("https://example.com/return".to_string()),
webhook_url: Some("https://example.com/webhook".to_string()),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(address),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_test"))),
}),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_125_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
}),
shipping_address: None,
};
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
PaymentServiceAuthorizeRequest {
amount: unique_amount,
minor_amount: unique_amount,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_125_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
}),
shipping_address: None,
};
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
PaymentServiceAuthorizeRequest {
amount: unique_amount,
minor_amount: unique_amount,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
return_url: Some("https://example.com/return".to_string()),
webhook_url: Some("https://example.com/webhook".to_string()),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(address),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_test"))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
..Default::default()
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_125_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
}),
shipping_address: None,
};
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
PaymentServiceAuthorizeRequest {
amount: unique_amount,
minor_amount: unique_amount,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
return_url: Some("https://example.com/return".to_string()),
webhook_url: Some("https://example.com/webhook".to_string()),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(address),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_test"))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
..Default::default()
}
}
fn create_payment_sync_request(transaction_id: &str, amount: i64) -> PaymentServiceGetRequest {
PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_sync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
}
}
fn create_payment_capture_request(
transaction_id: &str,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_150_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
..Default::default()
}
}
fn create_payment_sync_request(transaction_id: &str, amount: i64) -> PaymentServiceGetRequest {
PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_sync"))),
}),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_150_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
..Default::default()
}
}
fn create_payment_sync_request(transaction_id: &str, amount: i64) -> PaymentServiceGetRequest {
PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_sync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
}
}
fn create_payment_capture_request(
transaction_id: &str,
amount: i64,
) -> PaymentServiceCaptureRequest {
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_150_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
..Default::default()
}
}
fn create_payment_sync_request(transaction_id: &str, amount: i64) -> PaymentServiceGetRequest {
PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_sync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
}
}
fn create_payment_capture_request(
transaction_id: &str,
amount: i64,
) -> PaymentServiceCaptureRequest {
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: amount,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
request_ref_id: None,
..Default::default()
}
}
fn create_payment_void_request(transaction_id: &str, amount: i64) -> PaymentServiceVoidRequest {
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_void"))),
}),
all_keys_required: None,
browser_info: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_175_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: i64,
) -> PaymentServiceCaptureRequest {
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: amount,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
request_ref_id: None,
..Default::default()
}
}
fn create_payment_void_request(transaction_id: &str, amount: i64) -> PaymentServiceVoidRequest {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_175_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: i64,
) -> PaymentServiceCaptureRequest {
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: amount,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
request_ref_id: None,
..Default::default()
}
}
fn create_payment_void_request(transaction_id: &str, amount: i64) -> PaymentServiceVoidRequest {
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_void"))),
}),
all_keys_required: None,
browser_info: None,
amount: Some(amount),
currency: Some(i32::from(Currency::Usd)),
..Default::default()
}
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_175_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: i64,
) -> PaymentServiceCaptureRequest {
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: amount,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
request_ref_id: None,
..Default::default()
}
}
fn create_payment_void_request(transaction_id: &str, amount: i64) -> PaymentServiceVoidRequest {
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_void"))),
}),
all_keys_required: None,
browser_info: None,
amount: Some(amount),
currency: Some(i32::from(Currency::Usd)),
..Default::default()
}
}
fn create_refund_request(transaction_id: &str, amount: i64) -> PaymentServiceRefundRequest {
PaymentServiceRefundRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("refund"))),
}),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: amount,
refund_amount: amount,
minor_payment_amount: amount,
minor_refund_amount: amount,
..Default::default()
}
}
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
response
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_200_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: Some(amount),
currency: Some(i32::from(Currency::Usd)),
..Default::default()
}
}
fn create_refund_request(transaction_id: &str, amount: i64) -> PaymentServiceRefundRequest {
PaymentServiceRefundRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("refund"))),
}),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_200_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: Some(amount),
currency: Some(i32::from(Currency::Usd)),
..Default::default()
}
}
fn create_refund_request(transaction_id: &str, amount: i64) -> PaymentServiceRefundRequest {
PaymentServiceRefundRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("refund"))),
}),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: amount,
refund_amount: amount,
minor_payment_amount: amount,
minor_refund_amount: amount,
..Default::default()
}
}
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
response
.transaction_id
.as_ref()
.and_then(|id| id.id_type.as_ref())
.and_then(|id_type| match id_type {
IdType::Id(connector_txn_id) => Some(connector_txn_id.clone()),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_200_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
amount: Some(amount),
currency: Some(i32::from(Currency::Usd)),
..Default::default()
}
}
fn create_refund_request(transaction_id: &str, amount: i64) -> PaymentServiceRefundRequest {
PaymentServiceRefundRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("refund"))),
}),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: amount,
refund_amount: amount,
minor_payment_amount: amount,
minor_refund_amount: amount,
..Default::default()
}
}
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
response
.transaction_id
.as_ref()
.and_then(|id| id.id_type.as_ref())
.and_then(|id_type| match id_type {
IdType::Id(connector_txn_id) => Some(connector_txn_id.clone()),
_ => None,
})
.expect("Failed to extract connector transaction ID from response")
}
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_225_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.transaction_id
.as_ref()
.and_then(|id| id.id_type.as_ref())
.and_then(|id_type| match id_type {
IdType::Id(connector_txn_id) => Some(connector_txn_id.clone()),
_ => None,
})
.expect("Failed to extract connector transaction ID from response")
}
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_225_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.transaction_id
.as_ref()
.and_then(|id| id.id_type.as_ref())
.and_then(|id_type| match id_type {
IdType::Id(connector_txn_id) => Some(connector_txn_id.clone()),
_ => None,
})
.expect("Failed to extract connector transaction ID from response")
}
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
"Recurring payment using saved payment method".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(Identifier {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_225_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.transaction_id
.as_ref()
.and_then(|id| id.id_type.as_ref())
.and_then(|id_type| match id_type {
IdType::Id(connector_txn_id) => Some(connector_txn_id.clone()),
_ => None,
})
.expect("Failed to extract connector transaction ID from response")
}
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
// Use random amount to avoid duplicates
let mut rng = rand::thread_rng();
let unique_amount = rng.gen_range(1000..10000); // Amount between $10.00 and $100.00
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
"Recurring payment using saved payment method".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("repeat"))),
}),
mandate_reference: Some(mandate_reference),
amount: unique_amount,
currency: i32::from(Currency::Usd),
minor_amount: unique_amount,
merchant_order_reference_id: Some(generate_unique_id("repeat_order")),
metadata,
webhook_url: None,
capture_method: None,
email: Some(Secret::new(TEST_EMAIL.to_string())),
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
..Default::default()
}
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_250_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
"Recurring payment using saved payment method".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("repeat"))),
}),
mandate_reference: Some(mandate_reference),
amount: unique_amount,
currency: i32::from(Currency::Usd),
minor_amount: unique_amount,
merchant_order_reference_id: Some(generate_unique_id("repeat_order")),
metadata,
webhook_url: None,
capture_method: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_250_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
"Recurring payment using saved payment method".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("repeat"))),
}),
mandate_reference: Some(mandate_reference),
amount: unique_amount,
currency: i32::from(Currency::Usd),
minor_amount: unique_amount,
merchant_order_reference_id: Some(generate_unique_id("repeat_order")),
metadata,
webhook_url: None,
capture_method: None,
email: Some(Secret::new(TEST_EMAIL.to_string())),
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
..Default::default()
}
}
fn create_register_request() -> PaymentServiceRegisterRequest {
create_register_request_with_prefix("payload_mandate")
}
fn create_register_request_with_prefix(prefix: &str) -> PaymentServiceRegisterRequest {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_250_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
"Recurring payment using saved payment method".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("repeat"))),
}),
mandate_reference: Some(mandate_reference),
amount: unique_amount,
currency: i32::from(Currency::Usd),
minor_amount: unique_amount,
merchant_order_reference_id: Some(generate_unique_id("repeat_order")),
metadata,
webhook_url: None,
capture_method: None,
email: Some(Secret::new(TEST_EMAIL.to_string())),
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
..Default::default()
}
}
fn create_register_request() -> PaymentServiceRegisterRequest {
create_register_request_with_prefix("payload_mandate")
}
fn create_register_request_with_prefix(prefix: &str) -> PaymentServiceRegisterRequest {
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Use random values to create unique data to avoid duplicate detection
let mut rng = rand::thread_rng();
let random_street_num = rng.gen_range(1000..9999);
let unique_zip = format!("{}", rng.gen_range(10000..99999));
let random_id = rng.gen_range(1000..9999);
let unique_email = format!("customer{}@example.com", random_id);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_275_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
fn create_register_request() -> PaymentServiceRegisterRequest {
create_register_request_with_prefix("payload_mandate")
}
fn create_register_request_with_prefix(prefix: &str) -> PaymentServiceRegisterRequest {
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_275_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
fn create_register_request() -> PaymentServiceRegisterRequest {
create_register_request_with_prefix("payload_mandate")
}
fn create_register_request_with_prefix(prefix: &str) -> PaymentServiceRegisterRequest {
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Use random values to create unique data to avoid duplicate detection
let mut rng = rand::thread_rng();
let random_street_num = rng.gen_range(1000..9999);
let unique_zip = format!("{}", rng.gen_range(10000..99999));
let random_id = rng.gen_range(1000..9999);
let unique_email = format!("customer{}@example.com", random_id);
let unique_first_name = format!("John{}", random_id);
PaymentServiceRegisterRequest {
minor_amount: Some(0), // Setup mandate with 0 amount
currency: i32::from(Currency::Usd),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_275_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
fn create_register_request() -> PaymentServiceRegisterRequest {
create_register_request_with_prefix("payload_mandate")
}
fn create_register_request_with_prefix(prefix: &str) -> PaymentServiceRegisterRequest {
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Use random values to create unique data to avoid duplicate detection
let mut rng = rand::thread_rng();
let random_street_num = rng.gen_range(1000..9999);
let unique_zip = format!("{}", rng.gen_range(10000..99999));
let random_id = rng.gen_range(1000..9999);
let unique_email = format!("customer{}@example.com", random_id);
let unique_first_name = format!("John{}", random_id);
PaymentServiceRegisterRequest {
minor_amount: Some(0), // Setup mandate with 0 amount
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
customer_name: Some(format!("{} Doe", unique_first_name)),
email: Some(unique_email.clone().into()),
customer_acceptance: Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0,
online_mandate_details: None,
}),
address: Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some(unique_first_name.into()),
last_name: Some("Doe".to_string().into()),
line1: Some(format!("{} Market St", random_street_num).into()),
line2: None,
line3: None,
city: Some("San Francisco".to_string().into()),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_300_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let unique_first_name = format!("John{}", random_id);
PaymentServiceRegisterRequest {
minor_amount: Some(0), // Setup mandate with 0 amount
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
customer_name: Some(format!("{} Doe", unique_first_name)),
email: Some(unique_email.clone().into()),
customer_acceptance: Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_300_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let unique_first_name = format!("John{}", random_id);
PaymentServiceRegisterRequest {
minor_amount: Some(0), // Setup mandate with 0 amount
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
customer_name: Some(format!("{} Doe", unique_first_name)),
email: Some(unique_email.clone().into()),
customer_acceptance: Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0,
online_mandate_details: None,
}),
address: Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some(unique_first_name.into()),
last_name: Some("Doe".to_string().into()),
line1: Some(format!("{} Market St", random_street_num).into()),
line2: None,
line3: None,
city: Some("San Francisco".to_string().into()),
state: Some("CA".to_string().into()),
zip_code: Some(unique_zip.into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_300_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let unique_first_name = format!("John{}", random_id);
PaymentServiceRegisterRequest {
minor_amount: Some(0), // Setup mandate with 0 amount
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
customer_name: Some(format!("{} Doe", unique_first_name)),
email: Some(unique_email.clone().into()),
customer_acceptance: Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0,
online_mandate_details: None,
}),
address: Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some(unique_first_name.into()),
last_name: Some("Doe".to_string().into()),
line1: Some(format!("{} Market St", random_street_num).into()),
line2: None,
line3: None,
city: Some("San Francisco".to_string().into()),
state: Some("CA".to_string().into()),
zip_code: Some(unique_zip.into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(unique_email.into()),
}),
shipping_address: None,
}),
auth_type: i32::from(AuthenticationType::NoThreeDs),
setup_future_usage: Some(i32::from(FutureUsage::OffSession)),
enrolled_for_3ds: false,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id(prefix))),
}),
metadata: HashMap::new(),
..Default::default()
}
}
#[tokio::test]
async fn test_health() {
grpc_test!(client, HealthClient<Channel>, {
let response = client
.check(Request::new(HealthCheckRequest {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_325_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
state: Some("CA".to_string().into()),
zip_code: Some(unique_zip.into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(unique_email.into()),
}),
shipping_address: None,
}),
auth_type: i32::from(AuthenticationType::NoThreeDs),
setup_future_usage: Some(i32::from(FutureUsage::OffSession)),
enrolled_for_3ds: false,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id(prefix))),
}),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_325_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
state: Some("CA".to_string().into()),
zip_code: Some(unique_zip.into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(unique_email.into()),
}),
shipping_address: None,
}),
auth_type: i32::from(AuthenticationType::NoThreeDs),
setup_future_usage: Some(i32::from(FutureUsage::OffSession)),
enrolled_for_3ds: false,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id(prefix))),
}),
metadata: HashMap::new(),
..Default::default()
}
}
#[tokio::test]
async fn test_health() {
grpc_test!(client, HealthClient<Channel>, {
let response = client
.check(Request::new(HealthCheckRequest {
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_325_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
state: Some("CA".to_string().into()),
zip_code: Some(unique_zip.into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(unique_email.into()),
}),
shipping_address: None,
}),
auth_type: i32::from(AuthenticationType::NoThreeDs),
setup_future_usage: Some(i32::from(FutureUsage::OffSession)),
enrolled_for_3ds: false,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id(prefix))),
}),
metadata: HashMap::new(),
..Default::default()
}
}
#[tokio::test]
async fn test_health() {
grpc_test!(client, HealthClient<Channel>, {
let response = client
.check(Request::new(HealthCheckRequest {
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
assert_eq!(
response.status(),
grpc_api_types::health_check::health_check_response::ServingStatus::Serving,
"Health check should return Serving status"
);
});
}
#[tokio::test]
async fn test_authorize_psync_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_350_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
assert_eq!(
response.status(),
grpc_api_types::health_check::health_check_response::ServingStatus::Serving,
"Health check should return Serving status"
);
});
}
#[tokio::test]
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_350_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
assert_eq!(
response.status(),
grpc_api_types::health_check::health_check_response::ServingStatus::Serving,
"Health check should return Serving status"
);
});
}
#[tokio::test]
async fn test_authorize_psync_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_350_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
assert_eq!(
response.status(),
grpc_api_types::health_check::health_check_response::ServingStatus::Serving,
"Health check should return Serving status"
);
});
}
#[tokio::test]
async fn test_authorize_psync_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
// Step 2: PSync
let sync_request = create_payment_sync_request(&transaction_id, amount);
let mut sync_grpc_request = Request::new(sync_request);
add_payload_metadata(&mut sync_grpc_request);
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC sync call failed")
.into_inner();
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_375_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 375,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_375_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
// Step 2: PSync
let sync_request = create_payment_sync_request(&transaction_id, amount);
let mut sync_grpc_request = Request::new(sync_request);
add_payload_metadata(&mut sync_grpc_request);
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC sync call failed")
.into_inner();
assert!(
sync_response.transaction_id.is_some(),
"Sync response should contain transaction ID"
);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 375,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_375_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
// Step 2: PSync
let sync_request = create_payment_sync_request(&transaction_id, amount);
let mut sync_grpc_request = Request::new(sync_request);
add_payload_metadata(&mut sync_grpc_request);
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC sync call failed")
.into_inner();
assert!(
sync_response.transaction_id.is_some(),
"Sync response should contain transaction ID"
);
// Step 3: Void
let void_request = create_payment_void_request(&transaction_id, amount);
let mut void_grpc_request = Request::new(void_request);
add_payload_metadata(&mut void_grpc_request);
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void call failed")
.into_inner();
assert_eq!(
void_response.status,
i32::from(PaymentStatus::Voided),
"Payment should be in Voided state after void"
);
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 375,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_400_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
assert!(
sync_response.transaction_id.is_some(),
"Sync response should contain transaction ID"
);
// Step 3: Void
let void_request = create_payment_void_request(&transaction_id, amount);
let mut void_grpc_request = Request::new(void_request);
add_payload_metadata(&mut void_grpc_request);
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void call failed")
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_400_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
assert!(
sync_response.transaction_id.is_some(),
"Sync response should contain transaction ID"
);
// Step 3: Void
let void_request = create_payment_void_request(&transaction_id, amount);
let mut void_grpc_request = Request::new(void_request);
add_payload_metadata(&mut void_grpc_request);
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void call failed")
.into_inner();
assert_eq!(
void_response.status,
i32::from(PaymentStatus::Voided),
"Payment should be in Voided state after void"
);
});
}
#[tokio::test]
async fn test_authorize_capture_refund_rsync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_400_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
assert!(
sync_response.transaction_id.is_some(),
"Sync response should contain transaction ID"
);
// Step 3: Void
let void_request = create_payment_void_request(&transaction_id, amount);
let mut void_grpc_request = Request::new(void_request);
add_payload_metadata(&mut void_grpc_request);
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void call failed")
.into_inner();
assert_eq!(
void_response.status,
i32::from(PaymentStatus::Voided),
"Payment should be in Voided state after void"
);
});
}
#[tokio::test]
async fn test_authorize_capture_refund_rsync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_425_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
#[tokio::test]
async fn test_authorize_capture_refund_rsync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_425_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
#[tokio::test]
async fn test_authorize_capture_refund_rsync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
// Step 2: Capture
let capture_request = create_payment_capture_request(&transaction_id, amount);
let mut capture_grpc_request = Request::new(capture_request);
add_payload_metadata(&mut capture_grpc_request);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_425_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
#[tokio::test]
async fn test_authorize_capture_refund_rsync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Step 1: Authorize with manual capture
let request = create_authorize_request(CaptureMethod::Manual);
let amount = request.minor_amount; // Capture amount from request
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let auth_response = client
.authorize(grpc_request)
.await
.expect("gRPC authorize call failed")
.into_inner();
let transaction_id = extract_transaction_id(&auth_response);
assert_eq!(
auth_response.status,
i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
// Step 2: Capture
let capture_request = create_payment_capture_request(&transaction_id, amount);
let mut capture_grpc_request = Request::new(capture_request);
add_payload_metadata(&mut capture_grpc_request);
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC capture call failed")
.into_inner();
assert_eq!(
capture_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in Charged state after capture"
);
// Step 3: Refund
let refund_request = create_refund_request(&transaction_id, amount);
let mut refund_grpc_request = Request::new(refund_request);
add_payload_metadata(&mut refund_grpc_request);
let refund_response = client
.refund(refund_grpc_request)
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_450_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
// Step 2: Capture
let capture_request = create_payment_capture_request(&transaction_id, amount);
let mut capture_grpc_request = Request::new(capture_request);
add_payload_metadata(&mut capture_grpc_request);
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC capture call failed")
.into_inner();
assert_eq!(
capture_response.status,
i32::from(PaymentStatus::Charged),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_450_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
// Step 2: Capture
let capture_request = create_payment_capture_request(&transaction_id, amount);
let mut capture_grpc_request = Request::new(capture_request);
add_payload_metadata(&mut capture_grpc_request);
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC capture call failed")
.into_inner();
assert_eq!(
capture_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in Charged state after capture"
);
// Step 3: Refund
let refund_request = create_refund_request(&transaction_id, amount);
let mut refund_grpc_request = Request::new(refund_request);
add_payload_metadata(&mut refund_grpc_request);
let refund_response = client
.refund(refund_grpc_request)
.await
.expect("gRPC refund call failed")
.into_inner();
let refund_id = refund_response.refund_id.clone();
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_450_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
// Step 2: Capture
let capture_request = create_payment_capture_request(&transaction_id, amount);
let mut capture_grpc_request = Request::new(capture_request);
add_payload_metadata(&mut capture_grpc_request);
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC capture call failed")
.into_inner();
assert_eq!(
capture_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in Charged state after capture"
);
// Step 3: Refund
let refund_request = create_refund_request(&transaction_id, amount);
let mut refund_grpc_request = Request::new(refund_request);
add_payload_metadata(&mut refund_grpc_request);
let refund_response = client
.refund(refund_grpc_request)
.await
.expect("gRPC refund call failed")
.into_inner();
let refund_id = refund_response.refund_id.clone();
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in RefundSuccess or RefundPending state"
);
// Step 4: RSync (Refund Sync)
let rsync_request = PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(refund_id)),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_rsync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_475_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.await
.expect("gRPC refund call failed")
.into_inner();
let refund_id = refund_response.refund_id.clone();
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in RefundSuccess or RefundPending state"
);
// Step 4: RSync (Refund Sync)
let rsync_request = PaymentServiceGetRequest {
transaction_id: Some(Identifier {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_475_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.await
.expect("gRPC refund call failed")
.into_inner();
let refund_id = refund_response.refund_id.clone();
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in RefundSuccess or RefundPending state"
);
// Step 4: RSync (Refund Sync)
let rsync_request = PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(refund_id)),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_rsync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
};
let mut rsync_grpc_request = Request::new(rsync_request);
add_payload_metadata(&mut rsync_grpc_request);
let rsync_response = client
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_475_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
.await
.expect("gRPC refund call failed")
.into_inner();
let refund_id = refund_response.refund_id.clone();
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in RefundSuccess or RefundPending state"
);
// Step 4: RSync (Refund Sync)
let rsync_request = PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(refund_id)),
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(generate_unique_id("payload_rsync"))),
}),
capture_method: None,
handle_response: None,
amount,
currency: i32::from(Currency::Usd),
state: None,
};
let mut rsync_grpc_request = Request::new(rsync_request);
add_payload_metadata(&mut rsync_grpc_request);
let rsync_response = client
.get(rsync_grpc_request)
.await
.expect("gRPC refund sync call failed")
.into_inner();
assert!(
rsync_response.transaction_id.is_some(),
"Refund sync response should contain transaction ID"
);
});
}
#[tokio::test]
async fn test_setup_mandate() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Create setup mandate request (zero amount payment to save card)
let request = create_register_request();
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_500_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
};
let mut rsync_grpc_request = Request::new(rsync_request);
add_payload_metadata(&mut rsync_grpc_request);
let rsync_response = client
.get(rsync_grpc_request)
.await
.expect("gRPC refund sync call failed")
.into_inner();
assert!(
rsync_response.transaction_id.is_some(),
"Refund sync response should contain transaction ID"
);
});
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_500_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
};
let mut rsync_grpc_request = Request::new(rsync_request);
add_payload_metadata(&mut rsync_grpc_request);
let rsync_response = client
.get(rsync_grpc_request)
.await
.expect("gRPC refund sync call failed")
.into_inner();
assert!(
rsync_response.transaction_id.is_some(),
"Refund sync response should contain transaction ID"
);
});
}
#[tokio::test]
async fn test_setup_mandate() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Create setup mandate request (zero amount payment to save card)
let request = create_register_request();
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let response = client
.register(grpc_request)
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_500_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
};
let mut rsync_grpc_request = Request::new(rsync_request);
add_payload_metadata(&mut rsync_grpc_request);
let rsync_response = client
.get(rsync_grpc_request)
.await
.expect("gRPC refund sync call failed")
.into_inner();
assert!(
rsync_response.transaction_id.is_some(),
"Refund sync response should contain transaction ID"
);
});
}
#[tokio::test]
async fn test_setup_mandate() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Wait 30 seconds before making API call to avoid parallel test conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
// Create setup mandate request (zero amount payment to save card)
let request = create_register_request();
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some() || mandate_ref.payment_method_id.is_some(),
"Mandate ID or payment method ID should be present"
);
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(!mandate_id.is_empty(), "Mandate ID should not be empty");
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_525_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_525_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some() || mandate_ref.payment_method_id.is_some(),
"Mandate ID or payment method ID should be present"
);
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(!mandate_id.is_empty(), "Mandate ID should not be empty");
}
if let Some(pm_id) = &mandate_ref.payment_method_id {
assert!(!pm_id.is_empty(), "Payment method ID should not be empty");
}
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_525_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
let mut grpc_request = Request::new(request);
add_payload_metadata(&mut grpc_request);
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some() || mandate_ref.payment_method_id.is_some(),
"Mandate ID or payment method ID should be present"
);
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(!mandate_id.is_empty(), "Mandate ID should not be empty");
}
if let Some(pm_id) = &mandate_ref.payment_method_id {
assert!(!pm_id.is_empty(), "Payment method ID should not be empty");
}
}
// Verify status is success
assert_eq!(
response.status,
i32::from(PaymentStatus::Charged),
"Setup mandate should be in Charged/Success state"
);
});
}
#[tokio::test]
//Ignored as getting "duplicate transaction" error when run in CI pipeline
#[ignore]
async fn test_repeat_payment() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// NOTE: This test may fail with "duplicate transaction" error if run too soon
// after other tests that use the same test card. Payload has duplicate detection.
tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
let register_request = create_register_request_with_prefix("payload_repeat_test");
let mut register_grpc_request = Request::new(register_request);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_550_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
if let Some(pm_id) = &mandate_ref.payment_method_id {
assert!(!pm_id.is_empty(), "Payment method ID should not be empty");
}
}
// Verify status is success
assert_eq!(
response.status,
i32::from(PaymentStatus::Charged),
"Setup mandate should be in Charged/Success state"
);
});
}
#[tokio::test]
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_550_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
if let Some(pm_id) = &mandate_ref.payment_method_id {
assert!(!pm_id.is_empty(), "Payment method ID should not be empty");
}
}
// Verify status is success
assert_eq!(
response.status,
i32::from(PaymentStatus::Charged),
"Setup mandate should be in Charged/Success state"
);
});
}
#[tokio::test]
//Ignored as getting "duplicate transaction" error when run in CI pipeline
#[ignore]
async fn test_repeat_payment() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// NOTE: This test may fail with "duplicate transaction" error if run too soon
// after other tests that use the same test card. Payload has duplicate detection.
tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
let register_request = create_register_request_with_prefix("payload_repeat_test");
let mut register_grpc_request = Request::new(register_request);
add_payload_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_550_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
if let Some(pm_id) = &mandate_ref.payment_method_id {
assert!(!pm_id.is_empty(), "Payment method ID should not be empty");
}
}
// Verify status is success
assert_eq!(
response.status,
i32::from(PaymentStatus::Charged),
"Setup mandate should be in Charged/Success state"
);
});
}
#[tokio::test]
//Ignored as getting "duplicate transaction" error when run in CI pipeline
#[ignore]
async fn test_repeat_payment() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// NOTE: This test may fail with "duplicate transaction" error if run too soon
// after other tests that use the same test card. Payload has duplicate detection.
tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
let register_request = create_register_request_with_prefix("payload_repeat_test");
let mut register_grpc_request = Request::new(register_request);
add_payload_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
if register_response.mandate_reference.is_none() {
panic!(
"Mandate reference should be present. Status: {}, Error: {:?}",
register_response.status, register_response.error_message
);
}
let mandate_ref = register_response
.mandate_reference
.as_ref()
.expect("Mandate reference should be present");
let mandate_id = mandate_ref
.mandate_id
.as_ref()
.expect("mandate_id should be present");
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_575_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
add_payload_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
if register_response.mandate_reference.is_none() {
panic!(
"Mandate reference should be present. Status: {}, Error: {:?}",
register_response.status, register_response.error_message
);
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_575_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
add_payload_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
if register_response.mandate_reference.is_none() {
panic!(
"Mandate reference should be present. Status: {}, Error: {:?}",
register_response.status, register_response.error_message
);
}
let mandate_ref = register_response
.mandate_reference
.as_ref()
.expect("Mandate reference should be present");
let mandate_id = mandate_ref
.mandate_id
.as_ref()
.expect("mandate_id should be present");
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_payload_metadata(&mut repeat_grpc_request);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_575_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
add_payload_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
if register_response.mandate_reference.is_none() {
panic!(
"Mandate reference should be present. Status: {}, Error: {:?}",
register_response.status, register_response.error_message
);
}
let mandate_ref = register_response
.mandate_reference
.as_ref()
.expect("Mandate reference should be present");
let mandate_id = mandate_ref
.mandate_id
.as_ref()
.expect("mandate_id should be present");
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_payload_metadata(&mut repeat_grpc_request);
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present in repeat payment response"
);
assert_eq!(
repeat_response.status,
i32::from(PaymentStatus::Charged),
"Repeat payment should be in Charged state with automatic capture"
);
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 49,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_600_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_payload_metadata(&mut repeat_grpc_request);
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present in repeat payment response"
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_600_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_payload_metadata(&mut repeat_grpc_request);
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present in repeat payment response"
);
assert_eq!(
repeat_response.status,
i32::from(PaymentStatus::Charged),
"Repeat payment should be in Charged state with automatic capture"
);
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 24,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_5183309079052678393_600_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/payload_payment_flows_test.rs
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_payload_metadata(&mut repeat_grpc_request);
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present in repeat payment response"
);
assert_eq!(
repeat_response.status,
i32::from(PaymentStatus::Charged),
"Repeat payment should be in Charged state with automatic capture"
);
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 24,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_0_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
#![allow(unused_imports)]
#![allow(dead_code)]
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
any::Any,
collections::HashMap,
str::FromStr,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_0_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
#![allow(unused_imports)]
#![allow(dead_code)]
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
any::Any,
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use cards::CardNumber;
use grpc_api_types::{
health_check::{health_client::HealthClient, HealthCheckRequest},
payments::{
card_payment_method_type, identifier::IdType, payment_method,
payment_service_client::PaymentServiceClient, AcceptanceType, Address, AuthenticationType,
BrowserInformation, CaptureMethod, CardDetails, CardPaymentMethodType, CountryAlpha2,
Currency, CustomerAcceptance, FutureUsage, Identifier, MandateReference, PaymentAddress,
PaymentMethod, PaymentMethodType, PaymentServiceAuthorizeRequest,
PaymentServiceAuthorizeResponse, PaymentServiceCaptureRequest, PaymentServiceGetRequest,
PaymentServiceRefundRequest, PaymentServiceRegisterRequest,
PaymentServiceRepeatEverythingRequest, PaymentServiceRepeatEverythingResponse,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_0_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
#![allow(unused_imports)]
#![allow(dead_code)]
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
any::Any,
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use cards::CardNumber;
use grpc_api_types::{
health_check::{health_client::HealthClient, HealthCheckRequest},
payments::{
card_payment_method_type, identifier::IdType, payment_method,
payment_service_client::PaymentServiceClient, AcceptanceType, Address, AuthenticationType,
BrowserInformation, CaptureMethod, CardDetails, CardPaymentMethodType, CountryAlpha2,
Currency, CustomerAcceptance, FutureUsage, Identifier, MandateReference, PaymentAddress,
PaymentMethod, PaymentMethodType, PaymentServiceAuthorizeRequest,
PaymentServiceAuthorizeResponse, PaymentServiceCaptureRequest, PaymentServiceGetRequest,
PaymentServiceRefundRequest, PaymentServiceRegisterRequest,
PaymentServiceRepeatEverythingRequest, PaymentServiceRepeatEverythingResponse,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use rand::{distributions::Alphanumeric, Rng};
use tonic::{transport::Channel, Request};
use uuid::Uuid;
// Function to generate random name
fn random_name() -> String {
rand::thread_rng()
.sample_iter(&Alphanumeric)
.take(8)
.map(char::from)
.collect()
}
// Constants for AuthorizeDotNet connector
const CONNECTOR_NAME: &str = "authorizedotnet";
// Test card data matching working grpcurl payload
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_25_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
Currency, CustomerAcceptance, FutureUsage, Identifier, MandateReference, PaymentAddress,
PaymentMethod, PaymentMethodType, PaymentServiceAuthorizeRequest,
PaymentServiceAuthorizeResponse, PaymentServiceCaptureRequest, PaymentServiceGetRequest,
PaymentServiceRefundRequest, PaymentServiceRegisterRequest,
PaymentServiceRepeatEverythingRequest, PaymentServiceRepeatEverythingResponse,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use rand::{distributions::Alphanumeric, Rng};
use tonic::{transport::Channel, Request};
use uuid::Uuid;
// Function to generate random name
fn random_name() -> String {
rand::thread_rng()
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 25,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_25_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
Currency, CustomerAcceptance, FutureUsage, Identifier, MandateReference, PaymentAddress,
PaymentMethod, PaymentMethodType, PaymentServiceAuthorizeRequest,
PaymentServiceAuthorizeResponse, PaymentServiceCaptureRequest, PaymentServiceGetRequest,
PaymentServiceRefundRequest, PaymentServiceRegisterRequest,
PaymentServiceRepeatEverythingRequest, PaymentServiceRepeatEverythingResponse,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use rand::{distributions::Alphanumeric, Rng};
use tonic::{transport::Channel, Request};
use uuid::Uuid;
// Function to generate random name
fn random_name() -> String {
rand::thread_rng()
.sample_iter(&Alphanumeric)
.take(8)
.map(char::from)
.collect()
}
// Constants for AuthorizeDotNet connector
const CONNECTOR_NAME: &str = "authorizedotnet";
// Test card data matching working grpcurl payload
const TEST_AMOUNT: i64 = 102; // Amount from working grpcurl
const TEST_CARD_NUMBER: &str = "5123456789012346"; // Mastercard from working grpcurl
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "123";
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 25,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_25_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
Currency, CustomerAcceptance, FutureUsage, Identifier, MandateReference, PaymentAddress,
PaymentMethod, PaymentMethodType, PaymentServiceAuthorizeRequest,
PaymentServiceAuthorizeResponse, PaymentServiceCaptureRequest, PaymentServiceGetRequest,
PaymentServiceRefundRequest, PaymentServiceRegisterRequest,
PaymentServiceRepeatEverythingRequest, PaymentServiceRepeatEverythingResponse,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use rand::{distributions::Alphanumeric, Rng};
use tonic::{transport::Channel, Request};
use uuid::Uuid;
// Function to generate random name
fn random_name() -> String {
rand::thread_rng()
.sample_iter(&Alphanumeric)
.take(8)
.map(char::from)
.collect()
}
// Constants for AuthorizeDotNet connector
const CONNECTOR_NAME: &str = "authorizedotnet";
// Test card data matching working grpcurl payload
const TEST_AMOUNT: i64 = 102; // Amount from working grpcurl
const TEST_CARD_NUMBER: &str = "5123456789012346"; // Mastercard from working grpcurl
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "123";
const TEST_CARD_HOLDER: &str = "TestCustomer0011uyty4";
const TEST_EMAIL_BASE: &str = "testcustomer001@gmail.com";
// Test data for repeat payment
const REPEAT_AMOUNT: i64 = 1000; // Amount for repeat payments
// Metadata for Authorize.Net
// Note: BASE64_METADATA is the base64 encoded version of this JSON:
// {"userFields":{"MerchantDefinedFieldName1":"MerchantDefinedFieldValue1","favorite_color":"blue"}}
const BASE64_METADATA: &str =
"eyJ1c2VyRmllbGRzIjp7Ik1lcmNoYW50RGVmaW5lZEZpZWxkTmFtZTEiOiJNZXJjaGFudERlZmluZWRGaWVsZFZhbHVlMSIsImZhdm9yaXRlX2NvbG9yIjoiYmx1ZSJ9fQ==";
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 25,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_50_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
const TEST_AMOUNT: i64 = 102; // Amount from working grpcurl
const TEST_CARD_NUMBER: &str = "5123456789012346"; // Mastercard from working grpcurl
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "123";
const TEST_CARD_HOLDER: &str = "TestCustomer0011uyty4";
const TEST_EMAIL_BASE: &str = "testcustomer001@gmail.com";
// Test data for repeat payment
const REPEAT_AMOUNT: i64 = 1000; // Amount for repeat payments
// Metadata for Authorize.Net
// Note: BASE64_METADATA is the base64 encoded version of this JSON:
// {"userFields":{"MerchantDefinedFieldName1":"MerchantDefinedFieldValue1","favorite_color":"blue"}}
const BASE64_METADATA: &str =
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_50_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
const TEST_AMOUNT: i64 = 102; // Amount from working grpcurl
const TEST_CARD_NUMBER: &str = "5123456789012346"; // Mastercard from working grpcurl
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "123";
const TEST_CARD_HOLDER: &str = "TestCustomer0011uyty4";
const TEST_EMAIL_BASE: &str = "testcustomer001@gmail.com";
// Test data for repeat payment
const REPEAT_AMOUNT: i64 = 1000; // Amount for repeat payments
// Metadata for Authorize.Net
// Note: BASE64_METADATA is the base64 encoded version of this JSON:
// {"userFields":{"MerchantDefinedFieldName1":"MerchantDefinedFieldValue1","favorite_color":"blue"}}
const BASE64_METADATA: &str =
"eyJ1c2VyRmllbGRzIjp7Ik1lcmNoYW50RGVmaW5lZEZpZWxkTmFtZTEiOiJNZXJjaGFudERlZmluZWRGaWVsZFZhbHVlMSIsImZhdm9yaXRlX2NvbG9yIjoiYmx1ZSJ9fQ==";
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to generate unique email
fn generate_unique_email() -> String {
format!("testcustomer{}@gmail.com", get_timestamp())
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_50_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
const TEST_AMOUNT: i64 = 102; // Amount from working grpcurl
const TEST_CARD_NUMBER: &str = "5123456789012346"; // Mastercard from working grpcurl
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "123";
const TEST_CARD_HOLDER: &str = "TestCustomer0011uyty4";
const TEST_EMAIL_BASE: &str = "testcustomer001@gmail.com";
// Test data for repeat payment
const REPEAT_AMOUNT: i64 = 1000; // Amount for repeat payments
// Metadata for Authorize.Net
// Note: BASE64_METADATA is the base64 encoded version of this JSON:
// {"userFields":{"MerchantDefinedFieldName1":"MerchantDefinedFieldValue1","favorite_color":"blue"}}
const BASE64_METADATA: &str =
"eyJ1c2VyRmllbGRzIjp7Ik1lcmNoYW50RGVmaW5lZEZpZWxkTmFtZTEiOiJNZXJjaGFudERlZmluZWRGaWVsZFZhbHVlMSIsImZhdm9yaXRlX2NvbG9yIjoiYmx1ZSJ9fQ==";
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to generate unique email
fn generate_unique_email() -> String {
format!("testcustomer{}@gmail.com", get_timestamp())
}
// Helper function to generate unique request reference ID
fn generate_unique_request_ref_id(prefix: &str) -> String {
format!("{}_{}", prefix, &Uuid::new_v4().simple().to_string()[..8])
}
// Helper function to add AuthorizeDotNet metadata headers to a request
fn add_authorizenet_metadata<T>(request: &mut Request<T>) {
// Get API credentials using the common credential loading utility
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load Authorize.Net credentials");
let (api_key, key1) = match auth {
domain_types::router_data::ConnectorAuthType::BodyKey { api_key, key1 } => {
(api_key.expose(), key1.expose())
}
_ => panic!("Expected BodyKey auth type for Authorize.Net"),
};
request.metadata_mut().append(
"x-connector",
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_75_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to generate unique email
fn generate_unique_email() -> String {
format!("testcustomer{}@gmail.com", get_timestamp())
}
// Helper function to generate unique request reference ID
fn generate_unique_request_ref_id(prefix: &str) -> String {
format!("{}_{}", prefix, &Uuid::new_v4().simple().to_string()[..8])
}
// Helper function to add AuthorizeDotNet metadata headers to a request
fn add_authorizenet_metadata<T>(request: &mut Request<T>) {
// Get API credentials using the common credential loading utility
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load Authorize.Net credentials");
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_75_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to generate unique email
fn generate_unique_email() -> String {
format!("testcustomer{}@gmail.com", get_timestamp())
}
// Helper function to generate unique request reference ID
fn generate_unique_request_ref_id(prefix: &str) -> String {
format!("{}_{}", prefix, &Uuid::new_v4().simple().to_string()[..8])
}
// Helper function to add AuthorizeDotNet metadata headers to a request
fn add_authorizenet_metadata<T>(request: &mut Request<T>) {
// Get API credentials using the common credential loading utility
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load Authorize.Net credentials");
let (api_key, key1) = match auth {
domain_types::router_data::ConnectorAuthType::BodyKey { api_key, key1 } => {
(api_key.expose(), key1.expose())
}
_ => panic!("Expected BodyKey auth type for Authorize.Net"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"body-key".parse().expect("Failed to parse x-auth"),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_75_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to generate unique email
fn generate_unique_email() -> String {
format!("testcustomer{}@gmail.com", get_timestamp())
}
// Helper function to generate unique request reference ID
fn generate_unique_request_ref_id(prefix: &str) -> String {
format!("{}_{}", prefix, &Uuid::new_v4().simple().to_string()[..8])
}
// Helper function to add AuthorizeDotNet metadata headers to a request
fn add_authorizenet_metadata<T>(request: &mut Request<T>) {
// Get API credentials using the common credential loading utility
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load Authorize.Net credentials");
let (api_key, key1) = match auth {
domain_types::router_data::ConnectorAuthType::BodyKey { api_key, key1 } => {
(api_key.expose(), key1.expose())
}
_ => panic!("Expected BodyKey auth type for Authorize.Net"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"body-key".parse().expect("Failed to parse x-auth"),
);
request.metadata_mut().append(
"x-api-key",
api_key.parse().expect("Failed to parse x-api-key"),
);
request
.metadata_mut()
.append("x-key1", key1.parse().expect("Failed to parse x-key1"));
// Add merchant ID which is required by the server
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
// Add tenant ID which is required by the server
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_100_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"body-key".parse().expect("Failed to parse x-auth"),
);
request.metadata_mut().append(
"x-api-key",
api_key.parse().expect("Failed to parse x-api-key"),
);
request
.metadata_mut()
.append("x-key1", key1.parse().expect("Failed to parse x-key1"));
// Add merchant ID which is required by the server
request.metadata_mut().append(
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_100_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"body-key".parse().expect("Failed to parse x-auth"),
);
request.metadata_mut().append(
"x-api-key",
api_key.parse().expect("Failed to parse x-api-key"),
);
request
.metadata_mut()
.append("x-key1", key1.parse().expect("Failed to parse x-key1"));
// Add merchant ID which is required by the server
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
// Add tenant ID which is required by the server
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
// Add request ID which is required by the server
request.metadata_mut().append(
"x-request-id",
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_100_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"body-key".parse().expect("Failed to parse x-auth"),
);
request.metadata_mut().append(
"x-api-key",
api_key.parse().expect("Failed to parse x-api-key"),
);
request
.metadata_mut()
.append("x-key1", key1.parse().expect("Failed to parse x-key1"));
// Add merchant ID which is required by the server
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
// Add tenant ID which is required by the server
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
// Add request ID which is required by the server
request.metadata_mut().append(
"x-request-id",
generate_unique_request_ref_id("req")
.parse()
.expect("Failed to parse x-request-id"),
);
// Add connector request reference ID which is required for our error handling
request.metadata_mut().append(
"x-connector-request-reference-id",
generate_unique_request_ref_id("conn_ref")
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
// First try to get the transaction ID from transaction_id field
match &response.transaction_id {
Some(id) => match &id.id_type {
Some(id_type) => match id_type {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_125_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Add request ID which is required by the server
request.metadata_mut().append(
"x-request-id",
generate_unique_request_ref_id("req")
.parse()
.expect("Failed to parse x-request-id"),
);
// Add connector request reference ID which is required for our error handling
request.metadata_mut().append(
"x-connector-request-reference-id",
generate_unique_request_ref_id("conn_ref")
.parse()
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_125_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Add request ID which is required by the server
request.metadata_mut().append(
"x-request-id",
generate_unique_request_ref_id("req")
.parse()
.expect("Failed to parse x-request-id"),
);
// Add connector request reference ID which is required for our error handling
request.metadata_mut().append(
"x-connector-request-reference-id",
generate_unique_request_ref_id("conn_ref")
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
// First try to get the transaction ID from transaction_id field
match &response.transaction_id {
Some(id) => match &id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_id_type_{}", get_timestamp()),
},
None => format!("no_id_type_{}", get_timestamp()),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_125_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Add request ID which is required by the server
request.metadata_mut().append(
"x-request-id",
generate_unique_request_ref_id("req")
.parse()
.expect("Failed to parse x-request-id"),
);
// Add connector request reference ID which is required for our error handling
request.metadata_mut().append(
"x-connector-request-reference-id",
generate_unique_request_ref_id("conn_ref")
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
// First try to get the transaction ID from transaction_id field
match &response.transaction_id {
Some(id) => match &id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_id_type_{}", get_timestamp()),
},
None => format!("no_id_type_{}", get_timestamp()),
},
None => {
// Fallback to response_ref_id if transaction_id is not available
if let Some(ref_id) = &response.response_ref_id {
match &ref_id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_ref_id_{}", get_timestamp()),
},
None => format!("no_ref_id_type_{}", get_timestamp()),
}
} else {
format!("no_transaction_id_{}", get_timestamp())
}
}
}
}
// Helper function to create a repeat payment request (matching your JSON format)
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_150_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_id_type_{}", get_timestamp()),
},
None => format!("no_id_type_{}", get_timestamp()),
},
None => {
// Fallback to response_ref_id if transaction_id is not available
if let Some(ref_id) = &response.response_ref_id {
match &ref_id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_ref_id_{}", get_timestamp()),
},
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_150_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_id_type_{}", get_timestamp()),
},
None => format!("no_id_type_{}", get_timestamp()),
},
None => {
// Fallback to response_ref_id if transaction_id is not available
if let Some(ref_id) = &response.response_ref_id {
match &ref_id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_ref_id_{}", get_timestamp()),
},
None => format!("no_ref_id_type_{}", get_timestamp()),
}
} else {
format!("no_transaction_id_{}", get_timestamp())
}
}
}
}
// Helper function to create a repeat payment request (matching your JSON format)
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("repeat_req"))),
};
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_150_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_id_type_{}", get_timestamp()),
},
None => format!("no_id_type_{}", get_timestamp()),
},
None => {
// Fallback to response_ref_id if transaction_id is not available
if let Some(ref_id) = &response.response_ref_id {
match &ref_id.id_type {
Some(id_type) => match id_type {
IdType::Id(id) => id.clone(),
IdType::EncodedData(id) => id.clone(),
_ => format!("unknown_ref_id_{}", get_timestamp()),
},
None => format!("no_ref_id_type_{}", get_timestamp()),
}
} else {
format!("no_transaction_id_{}", get_timestamp())
}
}
}
}
// Helper function to create a repeat payment request (matching your JSON format)
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("repeat_req"))),
};
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
// Create metadata matching your JSON format
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
"Monthly subscription payment".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(request_ref_id),
mandate_reference: Some(mandate_reference),
amount: REPEAT_AMOUNT,
currency: i32::from(Currency::Usd),
minor_amount: REPEAT_AMOUNT,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_175_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("repeat_req"))),
};
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
// Create metadata matching your JSON format
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_175_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("repeat_req"))),
};
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
// Create metadata matching your JSON format
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
"Monthly subscription payment".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(request_ref_id),
mandate_reference: Some(mandate_reference),
amount: REPEAT_AMOUNT,
currency: i32::from(Currency::Usd),
minor_amount: REPEAT_AMOUNT,
merchant_order_reference_id: Some(format!("repeat_order_{}", get_timestamp())),
metadata,
webhook_url: Some("https://your-webhook-url.com/payments/webhook".to_string()),
capture_method: None,
email: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_175_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
#[allow(clippy::field_reassign_with_default)]
fn create_repeat_payment_request(mandate_id: &str) -> PaymentServiceRepeatEverythingRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("repeat_req"))),
};
let mandate_reference = MandateReference {
mandate_id: Some(mandate_id.to_string()),
payment_method_id: None,
};
// Create metadata matching your JSON format
let mut metadata = HashMap::new();
metadata.insert("order_type".to_string(), "recurring".to_string());
metadata.insert(
"customer_note".to_string(),
"Monthly subscription payment".to_string(),
);
PaymentServiceRepeatEverythingRequest {
request_ref_id: Some(request_ref_id),
mandate_reference: Some(mandate_reference),
amount: REPEAT_AMOUNT,
currency: i32::from(Currency::Usd),
minor_amount: REPEAT_AMOUNT,
merchant_order_reference_id: Some(format!("repeat_order_{}", get_timestamp())),
metadata,
webhook_url: Some("https://your-webhook-url.com/payments/webhook".to_string()),
capture_method: None,
email: None,
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
recurring_mandate_payment_data: None,
address: None,
connector_customer_id: None,
description: None,
..Default::default()
}
}
// Test repeat payment (MIT) flow using previously created mandate
#[tokio::test]
async fn test_repeat_everything() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First, create a mandate using register
let register_request = create_register_request();
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_200_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
merchant_order_reference_id: Some(format!("repeat_order_{}", get_timestamp())),
metadata,
webhook_url: Some("https://your-webhook-url.com/payments/webhook".to_string()),
capture_method: None,
email: None,
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
recurring_mandate_payment_data: None,
address: None,
connector_customer_id: None,
description: None,
..Default::default()
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_200_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
merchant_order_reference_id: Some(format!("repeat_order_{}", get_timestamp())),
metadata,
webhook_url: Some("https://your-webhook-url.com/payments/webhook".to_string()),
capture_method: None,
email: None,
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
recurring_mandate_payment_data: None,
address: None,
connector_customer_id: None,
description: None,
..Default::default()
}
}
// Test repeat payment (MIT) flow using previously created mandate
#[tokio::test]
async fn test_repeat_everything() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First, create a mandate using register
let register_request = create_register_request();
let mut register_grpc_request = Request::new(register_request);
add_authorizenet_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_200_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
merchant_order_reference_id: Some(format!("repeat_order_{}", get_timestamp())),
metadata,
webhook_url: Some("https://your-webhook-url.com/payments/webhook".to_string()),
capture_method: None,
email: None,
browser_info: None,
test_mode: None,
payment_method_type: None,
merchant_account_metadata: HashMap::new(),
state: None,
recurring_mandate_payment_data: None,
address: None,
connector_customer_id: None,
description: None,
..Default::default()
}
}
// Test repeat payment (MIT) flow using previously created mandate
#[tokio::test]
async fn test_repeat_everything() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First, create a mandate using register
let register_request = create_register_request();
let mut register_grpc_request = Request::new(register_request);
add_authorizenet_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
register_response.mandate_reference.is_some(),
"Mandate reference should be present"
);
let mandate_id = register_response
.mandate_reference
.as_ref()
.unwrap()
.mandate_id
.as_ref()
.expect("Mandate ID should be present");
// Now perform a repeat payment using the mandate
let repeat_request = create_repeat_payment_request(mandate_id);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_225_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut register_grpc_request = Request::new(register_request);
add_authorizenet_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
register_response.mandate_reference.is_some(),
"Mandate reference should be present"
);
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_225_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut register_grpc_request = Request::new(register_request);
add_authorizenet_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
register_response.mandate_reference.is_some(),
"Mandate reference should be present"
);
let mandate_id = register_response
.mandate_reference
.as_ref()
.unwrap()
.mandate_id
.as_ref()
.expect("Mandate ID should be present");
// Now perform a repeat payment using the mandate
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_authorizenet_metadata(&mut repeat_grpc_request);
// Send the repeat payment request
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_225_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut register_grpc_request = Request::new(register_request);
add_authorizenet_metadata(&mut register_grpc_request);
let register_response = client
.register(register_grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify we got a mandate reference
assert!(
register_response.mandate_reference.is_some(),
"Mandate reference should be present"
);
let mandate_id = register_response
.mandate_reference
.as_ref()
.unwrap()
.mandate_id
.as_ref()
.expect("Mandate ID should be present");
// Now perform a repeat payment using the mandate
let repeat_request = create_repeat_payment_request(mandate_id);
let mut repeat_grpc_request = Request::new(repeat_request);
add_authorizenet_metadata(&mut repeat_grpc_request);
// Send the repeat payment request
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
// Verify the response
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present"
);
// // Verify no error occurred
// assert!(
// repeat_response.error_message.is_none()
// || repeat_response.error_message.as_ref().unwrap().is_empty(),
// "No error message should be present for successful repeat payment"
// );
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_250_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut repeat_grpc_request = Request::new(repeat_request);
add_authorizenet_metadata(&mut repeat_grpc_request);
// Send the repeat payment request
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
// Verify the response
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present"
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_250_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut repeat_grpc_request = Request::new(repeat_request);
add_authorizenet_metadata(&mut repeat_grpc_request);
// Send the repeat payment request
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
// Verify the response
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present"
);
// // Verify no error occurred
// assert!(
// repeat_response.error_message.is_none()
// || repeat_response.error_message.as_ref().unwrap().is_empty(),
// "No error message should be present for successful repeat payment"
// );
});
}
// Helper function to create a payment authorization request
#[allow(clippy::field_reassign_with_default)]
fn create_payment_authorize_request(
capture_method: common_enums::CaptureMethod,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_250_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut repeat_grpc_request = Request::new(repeat_request);
add_authorizenet_metadata(&mut repeat_grpc_request);
// Send the repeat payment request
let repeat_response = client
.repeat_everything(repeat_grpc_request)
.await
.expect("gRPC repeat_everything call failed")
.into_inner();
// Verify the response
assert!(
repeat_response.transaction_id.is_some(),
"Transaction ID should be present"
);
// // Verify no error occurred
// assert!(
// repeat_response.error_message.is_none()
// || repeat_response.error_message.as_ref().unwrap().is_empty(),
// "No error message should be present for successful repeat payment"
// );
});
}
// Helper function to create a payment authorization request
#[allow(clippy::field_reassign_with_default)]
fn create_payment_authorize_request(
capture_method: common_enums::CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Initialize with all required fields
let mut request = PaymentServiceAuthorizeRequest::default();
let mut request_ref_id = Identifier::default();
request_ref_id.id_type = Some(IdType::Id(
generate_unique_request_ref_id("req_"), // Using timestamp to make unique
));
request.request_ref_id = Some(request_ref_id);
// Set the basic payment details matching working grpcurl
request.amount = TEST_AMOUNT;
request.minor_amount = TEST_AMOUNT;
request.currency = 146; // Currency value from working grpcurl
// Set up card payment method using the correct structure
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_275_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to create a payment authorization request
#[allow(clippy::field_reassign_with_default)]
fn create_payment_authorize_request(
capture_method: common_enums::CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Initialize with all required fields
let mut request = PaymentServiceAuthorizeRequest::default();
let mut request_ref_id = Identifier::default();
request_ref_id.id_type = Some(IdType::Id(
generate_unique_request_ref_id("req_"), // Using timestamp to make unique
));
request.request_ref_id = Some(request_ref_id);
// Set the basic payment details matching working grpcurl
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_275_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to create a payment authorization request
#[allow(clippy::field_reassign_with_default)]
fn create_payment_authorize_request(
capture_method: common_enums::CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Initialize with all required fields
let mut request = PaymentServiceAuthorizeRequest::default();
let mut request_ref_id = Identifier::default();
request_ref_id.id_type = Some(IdType::Id(
generate_unique_request_ref_id("req_"), // Using timestamp to make unique
));
request.request_ref_id = Some(request_ref_id);
// Set the basic payment details matching working grpcurl
request.amount = TEST_AMOUNT;
request.minor_amount = TEST_AMOUNT;
request.currency = 146; // Currency value from working grpcurl
// Set up card payment method using the correct structure
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(2_i32), // Mastercard network for 5123456789012346
card_type: None,
card_issuing_country_alpha2: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_275_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Helper function to create a payment authorization request
#[allow(clippy::field_reassign_with_default)]
fn create_payment_authorize_request(
capture_method: common_enums::CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Initialize with all required fields
let mut request = PaymentServiceAuthorizeRequest::default();
let mut request_ref_id = Identifier::default();
request_ref_id.id_type = Some(IdType::Id(
generate_unique_request_ref_id("req_"), // Using timestamp to make unique
));
request.request_ref_id = Some(request_ref_id);
// Set the basic payment details matching working grpcurl
request.amount = TEST_AMOUNT;
request.minor_amount = TEST_AMOUNT;
request.currency = 146; // Currency value from working grpcurl
// Set up card payment method using the correct structure
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(2_i32), // Mastercard network for 5123456789012346
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
request.customer_id = Some("TEST_CONNECTOR".to_string());
// Set the customer information with unique email
request.email = Some(generate_unique_email().into());
// Generate random names for billing to prevent duplicate transaction errors
let billing_first_name = random_name();
let billing_last_name = random_name();
// Minimal address structure matching working grpcurl
request.address = Some(PaymentAddress {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_300_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(2_i32), // Mastercard network for 5123456789012346
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_7957748028931523727_300_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(2_i32), // Mastercard network for 5123456789012346
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
request.customer_id = Some("TEST_CONNECTOR".to_string());
// Set the customer information with unique email
request.email = Some(generate_unique_email().into());
// Generate random names for billing to prevent duplicate transaction errors
let billing_first_name = random_name();
let billing_last_name = random_name();
// Minimal address structure matching working grpcurl
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some(billing_first_name.into()),
last_name: Some(billing_last_name.into()),
line1: Some("14 Main Street".to_string().into()),
line2: None,
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.