id
stringlengths 20
153
| type
stringclasses 1
value | granularity
stringclasses 14
values | content
stringlengths 16
84.3k
| metadata
dict |
|---|---|---|---|---|
connector-service_snippet_559727822511286263_300_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Debug print has been removed
// Verify the response
assert!(
response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status
assert!(
response.status == i32::from(PaymentStatus::AuthenticationPending),
"Payment should be in AuthenticationPending state"
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_bluecode_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&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": 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_559727822511286263_325_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_bluecode_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_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": 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_559727822511286263_325_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_bluecode_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_bluecode_metadata(&mut sync_grpc_request);
// Send the sync 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": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_559727822511286263_325_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_bluecode_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_bluecode_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::AuthenticationPending),
"Payment should be in AuthenticationPending 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": 43,
"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_559727822511286263_350_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_bluecode_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::AuthenticationPending),
"Payment should be in AuthenticationPending 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": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_559727822511286263_350_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_bluecode_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::AuthenticationPending),
"Payment should be in AuthenticationPending 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": 18,
"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_559727822511286263_350_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/bluecode_payment_flows_test.rs
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_bluecode_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::AuthenticationPending),
"Payment should be in AuthenticationPending 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": 18,
"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_-2461549616556699474_0_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use base64::{engine::general_purpose, Engine};
|
{
"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_-2461549616556699474_0_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use base64::{engine::general_purpose, Engine};
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, refund_service_client::RefundServiceClient,
AuthenticationType, CaptureMethod, CardDetails, CardPaymentMethodType, Currency,
Identifier, PaymentMethod, PaymentServiceAuthorizeRequest, PaymentServiceAuthorizeResponse,
PaymentServiceCaptureRequest, PaymentServiceGetRequest, PaymentServiceRefundRequest,
PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, 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": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_0_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use base64::{engine::general_purpose, Engine};
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, refund_service_client::RefundServiceClient,
AuthenticationType, CaptureMethod, CardDetails, CardPaymentMethodType, Currency,
Identifier, PaymentMethod, PaymentServiceAuthorizeRequest, PaymentServiceAuthorizeResponse,
PaymentServiceCaptureRequest, PaymentServiceGetRequest, PaymentServiceRefundRequest,
PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Fiserv connector
const CONNECTOR_NAME: &str = "fiserv";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4005550000000019"; // Valid test card for Fiserv
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// 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": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_25_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Fiserv connector
const CONNECTOR_NAME: &str = "fiserv";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4005550000000019"; // Valid test card for Fiserv
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 = "Test User";
|
{
"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_-2461549616556699474_25_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Fiserv connector
const CONNECTOR_NAME: &str = "fiserv";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4005550000000019"; // Valid test card for Fiserv
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to add Fiserv metadata headers to a request
fn add_fiserv_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load fiserv 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": 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_-2461549616556699474_25_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Fiserv connector
const CONNECTOR_NAME: &str = "fiserv";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4005550000000019"; // Valid test card for Fiserv
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to add Fiserv metadata headers to a request
fn add_fiserv_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load fiserv credentials");
let (api_key, key1, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for fiserv"),
};
// Get the terminal_id from metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse 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": 25,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_50_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Helper function to add Fiserv metadata headers to a request
fn add_fiserv_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load fiserv credentials");
let (api_key, key1, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for fiserv"),
};
// Get the terminal_id from metadata
|
{
"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_-2461549616556699474_50_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Helper function to add Fiserv metadata headers to a request
fn add_fiserv_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load fiserv credentials");
let (api_key, key1, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for fiserv"),
};
// Get the terminal_id from metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"signature-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": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_50_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Helper function to add Fiserv metadata headers to a request
fn add_fiserv_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load fiserv credentials");
let (api_key, key1, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for fiserv"),
};
// Get the terminal_id from metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"signature-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"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
// Add the terminal_id in the metadata JSON
// This metadata must be in the proper format that the connector expects
let metadata_json = format!(r#"{{"terminal_id":"{terminal_id}"}}"#);
// For capture operations, the connector looks for terminal_id in connector_metadata
let base64_metadata = general_purpose::STANDARD.encode(metadata_json.as_bytes());
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": 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_-2461549616556699474_75_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-auth",
"signature-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"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
|
{
"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_-2461549616556699474_75_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-auth",
"signature-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"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
// Add the terminal_id in the metadata JSON
// This metadata must be in the proper format that the connector expects
let metadata_json = format!(r#"{{"terminal_id":"{terminal_id}"}}"#);
// For capture operations, the connector looks for terminal_id in connector_metadata
let base64_metadata = general_purpose::STANDARD.encode(metadata_json.as_bytes());
request.metadata_mut().append(
"x-metadata",
metadata_json.parse().expect("Failed to parse x-metadata"),
);
// Also add connector-metadata-id explicitly to handle capture operation
|
{
"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_-2461549616556699474_75_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-auth",
"signature-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"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
// Add the terminal_id in the metadata JSON
// This metadata must be in the proper format that the connector expects
let metadata_json = format!(r#"{{"terminal_id":"{terminal_id}"}}"#);
// For capture operations, the connector looks for terminal_id in connector_metadata
let base64_metadata = general_purpose::STANDARD.encode(metadata_json.as_bytes());
request.metadata_mut().append(
"x-metadata",
metadata_json.parse().expect("Failed to parse x-metadata"),
);
// Also add connector-metadata-id explicitly to handle capture operation
request.metadata_mut().append(
"connector-metadata-id",
metadata_json
.parse()
.expect("Failed to parse connector-metadata-id"),
);
// Add base64-encoded metadata as x-connector-metadata
request.metadata_mut().append(
"x-connector-metadata",
base64_metadata
.parse()
.expect("Failed to parse x-connector-metadata"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-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_-2461549616556699474_100_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
"x-metadata",
metadata_json.parse().expect("Failed to parse x-metadata"),
);
// Also add connector-metadata-id explicitly to handle capture operation
request.metadata_mut().append(
"connector-metadata-id",
metadata_json
.parse()
.expect("Failed to parse connector-metadata-id"),
);
// Add base64-encoded metadata as x-connector-metadata
request.metadata_mut().append(
"x-connector-metadata",
|
{
"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_-2461549616556699474_100_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
"x-metadata",
metadata_json.parse().expect("Failed to parse x-metadata"),
);
// Also add connector-metadata-id explicitly to handle capture operation
request.metadata_mut().append(
"connector-metadata-id",
metadata_json
.parse()
.expect("Failed to parse connector-metadata-id"),
);
// Add base64-encoded metadata as x-connector-metadata
request.metadata_mut().append(
"x-connector-metadata",
base64_metadata
.parse()
.expect("Failed to parse x-connector-metadata"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
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": 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_-2461549616556699474_100_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
"x-metadata",
metadata_json.parse().expect("Failed to parse x-metadata"),
);
// Also add connector-metadata-id explicitly to handle capture operation
request.metadata_mut().append(
"connector-metadata-id",
metadata_json
.parse()
.expect("Failed to parse connector-metadata-id"),
);
// Add base64-encoded metadata as x-connector-metadata
request.metadata_mut().append(
"x-connector-metadata",
base64_metadata
.parse()
.expect("Failed to parse x-connector-metadata"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
request.metadata_mut().append(
"x-connector-request-reference-id",
format!("conn_ref_{}", get_timestamp())
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract connector transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
match &response.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": 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_-2461549616556699474_125_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
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": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_125_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
request.metadata_mut().append(
"x-connector-request-reference-id",
format!("conn_ref_{}", get_timestamp())
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract connector transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
match &response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is 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": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_125_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
request.metadata_mut().append(
"x-connector-request-reference-id",
format!("conn_ref_{}", get_timestamp())
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract connector transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
match &response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is None"),
}
}
// Helper function to create a payment authorization request
fn create_payment_authorize_request(
capture_method: CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Get terminal_id for metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
|
{
"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_-2461549616556699474_150_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is None"),
}
}
// Helper function to create a payment authorization request
fn create_payment_authorize_request(
capture_method: CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Get terminal_id for metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
|
{
"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_-2461549616556699474_150_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is None"),
}
}
// Helper function to create a payment authorization request
fn create_payment_authorize_request(
capture_method: CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Get terminal_id for metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_meta_data".to_string(), connector_metadata_json);
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
|
{
"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_-2461549616556699474_150_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is None"),
}
}
// Helper function to create a payment authorization request
fn create_payment_authorize_request(
capture_method: CaptureMethod,
) -> PaymentServiceAuthorizeRequest {
// Get terminal_id for metadata
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_meta_data".to_string(), connector_metadata_json);
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: None,
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Initialize with all required fields
PaymentServiceAuthorizeRequest {
amount: TEST_AMOUNT,
minor_amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
|
{
"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_-2461549616556699474_175_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut metadata = HashMap::new();
metadata.insert("connector_meta_data".to_string(), connector_metadata_json);
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: None,
card_type: None,
card_issuing_country_alpha2: None,
bank_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": 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_-2461549616556699474_175_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut metadata = HashMap::new();
metadata.insert("connector_meta_data".to_string(), connector_metadata_json);
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: None,
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Initialize with all required fields
PaymentServiceAuthorizeRequest {
amount: TEST_AMOUNT,
minor_amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}), //i32::from(payment_method::PaymentMethod::Card),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(grpc_api_types::payments::PaymentAddress::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_-2461549616556699474_175_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut metadata = HashMap::new();
metadata.insert("connector_meta_data".to_string(), connector_metadata_json);
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: None,
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
// Initialize with all required fields
PaymentServiceAuthorizeRequest {
amount: TEST_AMOUNT,
minor_amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}), //i32::from(payment_method::PaymentMethod::Card),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(grpc_api_types::payments::PaymentAddress::default()),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("fiserv_test_{}", get_timestamp()))),
}), //format!("fiserv_test_{}", get_timestamp()),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
// payment_method_type: Some(i32::from(PaymentMethodType::Credit)),
metadata,
..Default::default()
}
}
// Helper function to create a payment sync request
fn create_payment_sync_request(transaction_id: &str) -> PaymentServiceGetRequest {
PaymentServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
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": 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_-2461549616556699474_200_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
card_type: Some(card_details),
})),
}), //i32::from(payment_method::PaymentMethod::Card),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(grpc_api_types::payments::PaymentAddress::default()),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("fiserv_test_{}", get_timestamp()))),
}), //format!("fiserv_test_{}", get_timestamp()),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
// payment_method_type: Some(i32::from(PaymentMethodType::Credit)),
metadata,
..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_-2461549616556699474_200_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
card_type: Some(card_details),
})),
}), //i32::from(payment_method::PaymentMethod::Card),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(grpc_api_types::payments::PaymentAddress::default()),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("fiserv_test_{}", get_timestamp()))),
}), //format!("fiserv_test_{}", get_timestamp()),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
// payment_method_type: Some(i32::from(PaymentMethodType::Credit)),
metadata,
..Default::default()
}
}
// Helper function to create a payment sync request
fn create_payment_sync_request(transaction_id: &str) -> 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(format!("fiserv_sync_{}", get_timestamp()))),
}),
// all_keys_required: None,
capture_method: None,
handle_response: 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": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_200_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
card_type: Some(card_details),
})),
}), //i32::from(payment_method::PaymentMethod::Card),
email: Some(TEST_EMAIL.to_string().into()),
address: Some(grpc_api_types::payments::PaymentAddress::default()),
auth_type: i32::from(AuthenticationType::NoThreeDs),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("fiserv_test_{}", get_timestamp()))),
}), //format!("fiserv_test_{}", get_timestamp()),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
// payment_method_type: Some(i32::from(PaymentMethodType::Credit)),
metadata,
..Default::default()
}
}
// Helper function to create a payment sync request
fn create_payment_sync_request(transaction_id: &str) -> 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(format!("fiserv_sync_{}", get_timestamp()))),
}),
// all_keys_required: None,
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
|
{
"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_-2461549616556699474_225_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
id_type: Some(IdType::Id(format!("fiserv_sync_{}", get_timestamp()))),
}),
// all_keys_required: None,
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
|
{
"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_-2461549616556699474_225_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
id_type: Some(IdType::Id(format!("fiserv_sync_{}", get_timestamp()))),
}),
// all_keys_required: None,
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut connector_metadata = HashMap::new();
connector_metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceCaptureRequest {
|
{
"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_-2461549616556699474_225_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
id_type: Some(IdType::Id(format!("fiserv_sync_{}", get_timestamp()))),
}),
// all_keys_required: None,
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut connector_metadata = HashMap::new();
connector_metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_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": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_250_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut connector_metadata = HashMap::new();
connector_metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata,
request_ref_id: None, // all_keys_required: None,
browser_info: 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_-2461549616556699474_250_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut connector_metadata = HashMap::new();
connector_metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
|
{
"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_-2461549616556699474_250_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let mut connector_metadata = HashMap::new();
connector_metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceCaptureRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let metadata = utils::credential_utils::load_connector_metadata(CONNECTOR_NAME)
.expect("Failed to load fiserv metadata");
let terminal_id = metadata
.get("terminal_id")
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceRefundRequest {
refund_id: format!("refund_{}", get_timestamp()),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: TEST_AMOUNT,
refund_amount: TEST_AMOUNT,
minor_payment_amount: TEST_AMOUNT,
minor_refund_amount: TEST_AMOUNT,
// connector_refund_id: None,
reason: None,
webhook_url: 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": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_275_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceRefundRequest {
refund_id: format!("refund_{}", get_timestamp()),
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": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_275_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceRefundRequest {
refund_id: format!("refund_{}", get_timestamp()),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: TEST_AMOUNT,
refund_amount: TEST_AMOUNT,
minor_payment_amount: TEST_AMOUNT,
minor_refund_amount: TEST_AMOUNT,
// connector_refund_id: None,
reason: None,
webhook_url: None,
metadata: metadata.clone(), // Add terminal_id for the main connector_metadata field
refund_metadata: metadata, // Add terminal_id for refund
browser_info: None,
merchant_account_id: 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": 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_-2461549616556699474_275_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.expect("terminal_id not found in fiserv metadata")
.clone();
// Create connector metadata as a proper JSON object
let mut connector_metadata = HashMap::new();
connector_metadata.insert("terminal_id".to_string(), terminal_id);
let connector_metadata_json =
serde_json::to_string(&connector_metadata).expect("Failed to serialize connector metadata");
let mut metadata = HashMap::new();
metadata.insert("connector_metadata".to_string(), connector_metadata_json);
PaymentServiceRefundRequest {
refund_id: format!("refund_{}", get_timestamp()),
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
currency: i32::from(Currency::Usd),
payment_amount: TEST_AMOUNT,
refund_amount: TEST_AMOUNT,
minor_payment_amount: TEST_AMOUNT,
minor_refund_amount: TEST_AMOUNT,
// connector_refund_id: None,
reason: None,
webhook_url: None,
metadata: metadata.clone(), // Add terminal_id for the main connector_metadata field
refund_metadata: metadata, // Add terminal_id for refund
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None, // all_keys_required: None,
state: None,
}
}
// Helper function to create a refund sync request
fn create_refund_sync_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
RefundServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
refund_id: refund_id.to_string(),
refund_reason: None,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
refund_metadata: HashMap::new(),
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": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_300_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
metadata: metadata.clone(), // Add terminal_id for the main connector_metadata field
refund_metadata: metadata, // Add terminal_id for refund
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None, // all_keys_required: None,
state: None,
}
}
// Helper function to create a refund sync request
fn create_refund_sync_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
RefundServiceGetRequest {
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": 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_-2461549616556699474_300_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
metadata: metadata.clone(), // Add terminal_id for the main connector_metadata field
refund_metadata: metadata, // Add terminal_id for refund
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None, // all_keys_required: None,
state: None,
}
}
// Helper function to create a refund sync request
fn create_refund_sync_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
RefundServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
refund_id: refund_id.to_string(),
refund_reason: None,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
refund_metadata: HashMap::new(),
state: None,
}
}
// Test for basic health check
#[tokio::test]
async fn test_health() {
grpc_test!(client, HealthClient<Channel>, {
let 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": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_300_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
metadata: metadata.clone(), // Add terminal_id for the main connector_metadata field
refund_metadata: metadata, // Add terminal_id for refund
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None, // all_keys_required: None,
state: None,
}
}
// Helper function to create a refund sync request
fn create_refund_sync_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
RefundServiceGetRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
refund_id: refund_id.to_string(),
refund_reason: None,
request_ref_id: None, // all_keys_required: None,
browser_info: None,
refund_metadata: HashMap::new(),
state: None,
}
}
// Test for basic health check
#[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
);
});
}
// Test payment authorization with auto capture
#[tokio::test]
async fn test_payment_authorization_auto_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request
let request = create_payment_authorize_request(CaptureMethod::Automatic);
|
{
"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_-2461549616556699474_325_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Test for basic health check
#[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
|
{
"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_-2461549616556699474_325_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Test for basic health check
#[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
);
});
}
// Test payment authorization with auto capture
#[tokio::test]
async fn test_payment_authorization_auto_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request
let request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers
let mut grpc_request = Request::new(request);
add_fiserv_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": 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_-2461549616556699474_325_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Test for basic health check
#[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
);
});
}
// Test payment authorization with auto capture
#[tokio::test]
async fn test_payment_authorization_auto_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request
let request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers
let mut grpc_request = Request::new(request);
add_fiserv_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Debug print has been removed
// Verify the response
assert!(
response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status
assert!(
|
{
"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_-2461549616556699474_350_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_fiserv_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Debug print has been removed
// Verify the 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": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_350_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_fiserv_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Debug print has been removed
// Verify the response
assert!(
response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status
assert!(
response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED 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": 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_-2461549616556699474_350_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_fiserv_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Debug print has been removed
// Verify the response
assert!(
response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status
assert!(
response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state"
);
});
}
// Test payment authorization with manual capture
#[tokio::test]
async fn test_payment_authorization_manual_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request with manual capture
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
assert!(
|
{
"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_-2461549616556699474_375_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state"
);
});
}
// Test payment authorization with manual capture
#[tokio::test]
async fn test_payment_authorization_manual_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request with manual capture
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_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": 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_-2461549616556699474_375_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state"
);
});
}
// Test payment authorization with manual capture
#[tokio::test]
async fn test_payment_authorization_manual_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request with manual capture
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
assert!(
auth_response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the 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_-2461549616556699474_375_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state"
);
});
}
// Test payment authorization with manual capture
#[tokio::test]
async fn test_payment_authorization_manual_capture() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the payment authorization request with manual capture
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
assert!(
auth_response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture"
);
// Create capture request (which already includes proper connector metadata)
let capture_request = create_payment_capture_request(&transaction_id);
// Add metadata headers for capture request
let mut capture_grpc_request = Request::new(capture_request);
add_fiserv_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_result = client.capture(capture_grpc_request).await;
// Add debugging for capture failure
let capture_response = match capture_result {
|
{
"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_-2461549616556699474_400_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
auth_response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture"
);
// Create capture request (which already includes proper connector metadata)
let capture_request = create_payment_capture_request(&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": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_400_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
auth_response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture"
);
// Create capture request (which already includes proper connector metadata)
let capture_request = create_payment_capture_request(&transaction_id);
// Add metadata headers for capture request
let mut capture_grpc_request = Request::new(capture_request);
add_fiserv_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_result = client.capture(capture_grpc_request).await;
// Add debugging for capture failure
let capture_response = match capture_result {
Ok(response) => response.into_inner(),
Err(status) => {
println!("=== FISERV CAPTURE DEBUG ===");
println!("Capture failed with status: {:?}", status);
println!("Error code: {:?}", status.code());
|
{
"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_-2461549616556699474_400_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
auth_response.transaction_id.is_some(),
"Resource ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture"
);
// Create capture request (which already includes proper connector metadata)
let capture_request = create_payment_capture_request(&transaction_id);
// Add metadata headers for capture request
let mut capture_grpc_request = Request::new(capture_request);
add_fiserv_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_result = client.capture(capture_grpc_request).await;
// Add debugging for capture failure
let capture_response = match capture_result {
Ok(response) => response.into_inner(),
Err(status) => {
println!("=== FISERV CAPTURE DEBUG ===");
println!("Capture failed with status: {:?}", status);
println!("Error code: {:?}", status.code());
println!("Error message: {:?}", status.message());
println!("Metadata: {:?}", status.metadata());
println!("=== END DEBUG ===");
panic!("gRPC payment_capture call failed: {}", status);
}
};
// Verify payment status is charged after capture
assert!(
capture_response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after capture"
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to 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": 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_-2461549616556699474_425_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Ok(response) => response.into_inner(),
Err(status) => {
println!("=== FISERV CAPTURE DEBUG ===");
println!("Capture failed with status: {:?}", status);
println!("Error code: {:?}", status.code());
println!("Error message: {:?}", status.message());
println!("Metadata: {:?}", status.metadata());
println!("=== END DEBUG ===");
panic!("gRPC payment_capture call failed: {}", status);
}
};
// Verify payment status is charged after capture
assert!(
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": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_425_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Ok(response) => response.into_inner(),
Err(status) => {
println!("=== FISERV CAPTURE DEBUG ===");
println!("Capture failed with status: {:?}", status);
println!("Error code: {:?}", status.code());
println!("Error message: {:?}", status.message());
println!("Metadata: {:?}", status.metadata());
println!("=== END DEBUG ===");
panic!("gRPC payment_capture call failed: {}", status);
}
};
// Verify payment status is charged after capture
assert!(
capture_response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after capture"
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_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_-2461549616556699474_425_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
Ok(response) => response.into_inner(),
Err(status) => {
println!("=== FISERV CAPTURE DEBUG ===");
println!("Capture failed with status: {:?}", status);
println!("Error code: {:?}", status.code());
println!("Error message: {:?}", status.message());
println!("Metadata: {:?}", status.metadata());
println!("=== END DEBUG ===");
panic!("gRPC payment_capture call failed: {}", status);
}
};
// Verify payment status is charged after capture
assert!(
capture_response.status == i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after capture"
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_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": 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_-2461549616556699474_450_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_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": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_450_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_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": 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_-2461549616556699474_450_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_request = create_payment_authorize_request(CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Create sync request
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
});
}
// Test refund flow - handles both success and error cases
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth 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": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_475_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
});
}
// Test refund flow - handles both success and error cases
#[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": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_475_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
});
}
// Test refund flow - handles both success and error cases
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize 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": 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_-2461549616556699474_475_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify the sync response
assert!(
sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in Authorized state"
);
});
}
// Test refund flow - handles both success and error cases
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status
assert!(
auth_response.status == i32::from(PaymentStatus::Charged)
|| auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state before attempting refund"
);
// Make sure the payment is fully processed by checking its status via sync
let sync_request = create_payment_sync_request(&transaction_id);
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Wait a bit longer to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
// Send the sync request to verify payment status
|
{
"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_-2461549616556699474_500_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status
assert!(
auth_response.status == i32::from(PaymentStatus::Charged)
|| auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state before attempting refund"
);
|
{
"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_-2461549616556699474_500_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status
assert!(
auth_response.status == i32::from(PaymentStatus::Charged)
|| auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state before attempting refund"
);
// Make sure the payment is fully processed by checking its status via sync
let sync_request = create_payment_sync_request(&transaction_id);
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Wait a bit longer to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
// Send the sync request to verify payment status
let _sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_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": 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_-2461549616556699474_500_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status
assert!(
auth_response.status == i32::from(PaymentStatus::Charged)
|| auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state before attempting refund"
);
// Make sure the payment is fully processed by checking its status via sync
let sync_request = create_payment_sync_request(&transaction_id);
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Wait a bit longer to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
// Send the sync request to verify payment status
let _sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_fiserv_metadata(&mut refund_grpc_request);
// Send the refund request and handle both success and error cases
let refund_result = client.refund(refund_grpc_request).await;
match refund_result {
Ok(response) => {
let refund_response = response.into_inner();
// Extract the refund ID
let _refund_id = refund_response.refund_id.clone();
// Verify the refund status
assert!(
|
{
"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_-2461549616556699474_525_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let _sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_fiserv_metadata(&mut refund_grpc_request);
// Send the refund request and handle both success and error cases
let refund_result = client.refund(refund_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": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_525_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let _sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_fiserv_metadata(&mut refund_grpc_request);
// Send the refund request and handle both success and error cases
let refund_result = client.refund(refund_grpc_request).await;
match refund_result {
Ok(response) => {
let refund_response = response.into_inner();
// Extract the refund ID
let _refund_id = refund_response.refund_id.clone();
// Verify the refund status
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in SUCCESS or PENDING 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": 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_-2461549616556699474_525_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let _sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_fiserv_metadata(&mut refund_grpc_request);
// Send the refund request and handle both success and error cases
let refund_result = client.refund(refund_grpc_request).await;
match refund_result {
Ok(response) => {
let refund_response = response.into_inner();
// Extract the refund ID
let _refund_id = refund_response.refund_id.clone();
// Verify the refund status
assert!(
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in SUCCESS or PENDING state"
);
}
Err(status) => {
// If the refund fails, it could be due to timing issues or payment not being in the right state
// This is acceptable for our test scenario - we're testing the connector functionality
// Verify the error message is reasonable
assert!(
status.message().contains("processing error")
|| status.message().contains("not found")
|| status.message().contains("payment state"),
"Error should be related to processing or payment state issues"
);
}
}
});
}
// Test refund sync flow - runs as a separate test since refund + sync is complex
#[tokio::test]
async fn test_refund_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": 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_-2461549616556699474_550_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in SUCCESS or PENDING state"
);
}
Err(status) => {
// If the refund fails, it could be due to timing issues or payment not being in the right state
// This is acceptable for our test scenario - we're testing the connector functionality
// Verify the error message is reasonable
assert!(
status.message().contains("processing error")
|| status.message().contains("not found")
|| status.message().contains("payment state"),
"Error should be related to processing or payment state issues"
|
{
"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_-2461549616556699474_550_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in SUCCESS or PENDING state"
);
}
Err(status) => {
// If the refund fails, it could be due to timing issues or payment not being in the right state
// This is acceptable for our test scenario - we're testing the connector functionality
// Verify the error message is reasonable
assert!(
status.message().contains("processing error")
|| status.message().contains("not found")
|| status.message().contains("payment state"),
"Error should be related to processing or payment state issues"
);
}
}
});
}
// Test refund sync flow - runs as a separate test since refund + sync is complex
#[tokio::test]
async fn test_refund_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
grpc_test!(refund_client, RefundServiceClient<Channel>, {
// Run a standalone test specifically for refund sync
// We'll directly test the payment sync functionality since the payment sync test already passes
// And use a mock refund ID for testing the refund sync functionality
|
{
"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_-2461549616556699474_550_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
refund_response.status == i32::from(RefundStatus::RefundSuccess)
|| refund_response.status == i32::from(RefundStatus::RefundPending),
"Refund should be in SUCCESS or PENDING state"
);
}
Err(status) => {
// If the refund fails, it could be due to timing issues or payment not being in the right state
// This is acceptable for our test scenario - we're testing the connector functionality
// Verify the error message is reasonable
assert!(
status.message().contains("processing error")
|| status.message().contains("not found")
|| status.message().contains("payment state"),
"Error should be related to processing or payment state issues"
);
}
}
});
}
// Test refund sync flow - runs as a separate test since refund + sync is complex
#[tokio::test]
async fn test_refund_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
grpc_test!(refund_client, RefundServiceClient<Channel>, {
// Run a standalone test specifically for refund sync
// We'll directly test the payment sync functionality since the payment sync test already passes
// And use a mock refund ID for testing the refund sync functionality
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID with debugging
let transaction_id = match &auth_response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
IdType::NoResponseIdMarker(_) => {
|
{
"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_-2461549616556699474_575_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
grpc_test!(refund_client, RefundServiceClient<Channel>, {
// Run a standalone test specifically for refund sync
// We'll directly test the payment sync functionality since the payment sync test already passes
// And use a mock refund ID for testing the refund sync functionality
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_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": 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_-2461549616556699474_575_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
grpc_test!(refund_client, RefundServiceClient<Channel>, {
// Run a standalone test specifically for refund sync
// We'll directly test the payment sync functionality since the payment sync test already passes
// And use a mock refund ID for testing the refund sync functionality
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID with debugging
let transaction_id = match &auth_response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
IdType::NoResponseIdMarker(_) => {
println!("=== FISERV REFUND SYNC DEBUG ===");
println!("NoResponseIdMarker detected in refund sync test");
println!("Auth response: {:?}", auth_response);
println!("=== END DEBUG ===");
panic!("NoResponseIdMarker found - authentication issue");
|
{
"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_-2461549616556699474_575_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
grpc_test!(refund_client, RefundServiceClient<Channel>, {
// Run a standalone test specifically for refund sync
// We'll directly test the payment sync functionality since the payment sync test already passes
// And use a mock refund ID for testing the refund sync functionality
// First create a payment
let auth_request = create_payment_authorize_request(CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_fiserv_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID with debugging
let transaction_id = match &auth_response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
IdType::NoResponseIdMarker(_) => {
println!("=== FISERV REFUND SYNC DEBUG ===");
println!("NoResponseIdMarker detected in refund sync test");
println!("Auth response: {:?}", auth_response);
println!("=== END DEBUG ===");
panic!("NoResponseIdMarker found - authentication issue");
}
IdType::EncodedData(_) => {
println!("EncodedData found instead of transaction ID");
panic!("Unexpected EncodedData in transaction ID");
}
},
None => panic!("Resource ID is None"),
};
// Wait for payment to process
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create sync request to check payment status
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync 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": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_600_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
println!("=== FISERV REFUND SYNC DEBUG ===");
println!("NoResponseIdMarker detected in refund sync test");
println!("Auth response: {:?}", auth_response);
println!("=== END DEBUG ===");
panic!("NoResponseIdMarker found - authentication issue");
}
IdType::EncodedData(_) => {
println!("EncodedData found instead of transaction ID");
panic!("Unexpected EncodedData in transaction ID");
}
},
None => panic!("Resource ID is None"),
};
// Wait for payment to process
|
{
"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_-2461549616556699474_600_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
println!("=== FISERV REFUND SYNC DEBUG ===");
println!("NoResponseIdMarker detected in refund sync test");
println!("Auth response: {:?}", auth_response);
println!("=== END DEBUG ===");
panic!("NoResponseIdMarker found - authentication issue");
}
IdType::EncodedData(_) => {
println!("EncodedData found instead of transaction ID");
panic!("Unexpected EncodedData in transaction ID");
}
},
None => panic!("Resource ID is None"),
};
// Wait for payment to process
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create sync request to check payment status
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_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": 30,
"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_-2461549616556699474_600_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
println!("=== FISERV REFUND SYNC DEBUG ===");
println!("NoResponseIdMarker detected in refund sync test");
println!("Auth response: {:?}", auth_response);
println!("=== END DEBUG ===");
panic!("NoResponseIdMarker found - authentication issue");
}
IdType::EncodedData(_) => {
println!("EncodedData found instead of transaction ID");
panic!("Unexpected EncodedData in transaction ID");
}
},
None => panic!("Resource ID is None"),
};
// Wait for payment to process
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create sync request to check payment status
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for sync request
let mut sync_grpc_request = Request::new(sync_request);
add_fiserv_metadata(&mut sync_grpc_request);
// Send the sync request
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify payment is in a good state
assert!(
sync_response.status == i32::from(PaymentStatus::Charged)
|| sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state"
);
// Use a mock refund ID for sync testing
// The format mimics what would come from a real Fiserv refund
let mock_refund_id = format!("refund_sync_test_{}", get_timestamp());
// Create refund sync request with our mock ID
let refund_sync_request = create_refund_sync_request(&transaction_id, &mock_refund_id);
// Add metadata headers for refund sync request
let mut refund_sync_grpc_request = Request::new(refund_sync_request);
add_fiserv_metadata(&mut refund_sync_grpc_request);
// Send the refund sync request and expect a not found response or pending status
|
{
"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": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_625_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify payment is in a good state
assert!(
sync_response.status == i32::from(PaymentStatus::Charged)
|| sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state"
);
// Use a mock refund ID for sync testing
// The format mimics what would come from a real Fiserv refund
|
{
"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": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_625_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify payment is in a good state
assert!(
sync_response.status == i32::from(PaymentStatus::Charged)
|| sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state"
);
// Use a mock refund ID for sync testing
// The format mimics what would come from a real Fiserv refund
let mock_refund_id = format!("refund_sync_test_{}", get_timestamp());
// Create refund sync request with our mock ID
let refund_sync_request = create_refund_sync_request(&transaction_id, &mock_refund_id);
// Add metadata headers for refund sync request
let mut refund_sync_grpc_request = Request::new(refund_sync_request);
add_fiserv_metadata(&mut refund_sync_grpc_request);
// Send the refund sync request and expect a not found response or pending status
let refund_sync_result = refund_client.get(refund_sync_grpc_request).await; //client.refund(refund_sync_grpc_request).await;
// For a mock refund ID, we expect either a failure (not found) or a pending status
// Both outcomes are valid for this test scenario
match refund_sync_result {
|
{
"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": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_625_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let sync_response = client
.get(sync_grpc_request)
.await
.expect("gRPC payment_sync call failed")
.into_inner();
// Verify payment is in a good state
assert!(
sync_response.status == i32::from(PaymentStatus::Charged)
|| sync_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in CHARGED or AUTHORIZED state"
);
// Use a mock refund ID for sync testing
// The format mimics what would come from a real Fiserv refund
let mock_refund_id = format!("refund_sync_test_{}", get_timestamp());
// Create refund sync request with our mock ID
let refund_sync_request = create_refund_sync_request(&transaction_id, &mock_refund_id);
// Add metadata headers for refund sync request
let mut refund_sync_grpc_request = Request::new(refund_sync_request);
add_fiserv_metadata(&mut refund_sync_grpc_request);
// Send the refund sync request and expect a not found response or pending status
let refund_sync_result = refund_client.get(refund_sync_grpc_request).await; //client.refund(refund_sync_grpc_request).await;
// For a mock refund ID, we expect either a failure (not found) or a pending status
// Both outcomes are valid for this test scenario
match refund_sync_result {
Ok(response) => {
// If we got a response, it should be in a pending state
let status = response.into_inner().status;
assert_eq!(
status,
i32::from(RefundStatus::RefundPending),
"If response received, refund should be in PENDING state for a mock ID"
);
}
Err(status) => {
// An error is also acceptable if the mock ID isn't found
assert!(
status.message().contains("not found")
|| status.message().contains("processing error"),
"Error should indicate refund not found or processing error"
);
}
}
});
});
|
{
"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": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_650_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let refund_sync_result = refund_client.get(refund_sync_grpc_request).await; //client.refund(refund_sync_grpc_request).await;
// For a mock refund ID, we expect either a failure (not found) or a pending status
// Both outcomes are valid for this test scenario
match refund_sync_result {
Ok(response) => {
// If we got a response, it should be in a pending state
let status = response.into_inner().status;
assert_eq!(
status,
i32::from(RefundStatus::RefundPending),
"If response received, refund should be in PENDING state for a mock ID"
);
}
Err(status) => {
|
{
"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": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_650_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let refund_sync_result = refund_client.get(refund_sync_grpc_request).await; //client.refund(refund_sync_grpc_request).await;
// For a mock refund ID, we expect either a failure (not found) or a pending status
// Both outcomes are valid for this test scenario
match refund_sync_result {
Ok(response) => {
// If we got a response, it should be in a pending state
let status = response.into_inner().status;
assert_eq!(
status,
i32::from(RefundStatus::RefundPending),
"If response received, refund should be in PENDING state for a mock ID"
);
}
Err(status) => {
// An error is also acceptable if the mock ID isn't found
assert!(
status.message().contains("not found")
|| status.message().contains("processing error"),
"Error should indicate refund not found or processing error"
);
}
}
});
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 26,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_-2461549616556699474_650_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/fiserv_payment_flows_test.rs
let refund_sync_result = refund_client.get(refund_sync_grpc_request).await; //client.refund(refund_sync_grpc_request).await;
// For a mock refund ID, we expect either a failure (not found) or a pending status
// Both outcomes are valid for this test scenario
match refund_sync_result {
Ok(response) => {
// If we got a response, it should be in a pending state
let status = response.into_inner().status;
assert_eq!(
status,
i32::from(RefundStatus::RefundPending),
"If response received, refund should be in PENDING state for a mock ID"
);
}
Err(status) => {
// An error is also acceptable if the mock ID isn't found
assert!(
status.message().contains("not found")
|| status.message().contains("processing error"),
"Error should indicate refund not found or processing error"
);
}
}
});
});
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 26,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6234876021404422116_0_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
collections::HashMap,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
use cards::CardNumber;
|
{
"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_6234876021404422116_0_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
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, refund_service_client::RefundServiceClient,
AuthenticationType, CaptureMethod, CardDetails, CardPaymentMethodType, Currency,
Identifier, PaymentMethod, PaymentServiceAuthorizeRequest, PaymentServiceAuthorizeResponse,
PaymentServiceCaptureRequest, PaymentServiceGetRequest, PaymentServiceRefundRequest,
PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Elavon 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": 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_6234876021404422116_0_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
mod common;
mod utils;
use std::{
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, refund_service_client::RefundServiceClient,
AuthenticationType, CaptureMethod, CardDetails, CardPaymentMethodType, Currency,
Identifier, PaymentMethod, PaymentServiceAuthorizeRequest, PaymentServiceAuthorizeResponse,
PaymentServiceCaptureRequest, PaymentServiceGetRequest, PaymentServiceRefundRequest,
PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Elavon connector
const CONNECTOR_NAME: &str = "elavon";
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4124939999999990";
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Note: This file contains tests for Elavon payment flows.
// We're implementing the tests one by one, starting with basic functionality.
// 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": 0,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6234876021404422116_25_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Elavon connector
const CONNECTOR_NAME: &str = "elavon";
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4124939999999990";
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Note: This file contains tests for Elavon payment flows.
|
{
"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_6234876021404422116_25_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Elavon connector
const CONNECTOR_NAME: &str = "elavon";
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4124939999999990";
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Note: This file contains tests for Elavon payment flows.
// We're implementing the tests one by one, starting with basic functionality.
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to add Elavon metadata headers to a request
fn add_elavon_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load elavon 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": 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_6234876021404422116_25_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
};
use hyperswitch_masking::{ExposeInterface, Secret};
use tonic::{transport::Channel, Request};
// Constants for Elavon connector
const CONNECTOR_NAME: &str = "elavon";
const TEST_AMOUNT: i64 = 1000;
const TEST_CARD_NUMBER: &str = "4124939999999990";
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 = "Test User";
const TEST_EMAIL: &str = "customer@example.com";
// Note: This file contains tests for Elavon payment flows.
// We're implementing the tests one by one, starting with basic functionality.
// Helper function to get current timestamp
fn get_timestamp() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs()
}
// Helper function to add Elavon metadata headers to a request
fn add_elavon_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load elavon credentials");
let (api_key, api_user, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for elavon"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"signature-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"),
|
{
"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_6234876021404422116_50_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
// Helper function to add Elavon metadata headers to a request
fn add_elavon_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load elavon credentials");
let (api_key, api_user, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for elavon"),
};
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": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6234876021404422116_50_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
// Helper function to add Elavon metadata headers to a request
fn add_elavon_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load elavon credentials");
let (api_key, api_user, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for elavon"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"signature-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", api_user.parse().expect("Failed to parse x-key1"));
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": 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_6234876021404422116_50_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
// Helper function to add Elavon metadata headers to a request
fn add_elavon_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load elavon credentials");
let (api_key, api_user, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => (api_key.expose(), key1.expose(), api_secret.expose()),
_ => panic!("Expected SignatureKey auth type for elavon"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request.metadata_mut().append(
"x-auth",
"signature-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", api_user.parse().expect("Failed to parse x-key1"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.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": 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_6234876021404422116_75_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
);
request
.metadata_mut()
.append("x-key1", api_user.parse().expect("Failed to parse x-key1"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-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": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6234876021404422116_75_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
);
request
.metadata_mut()
.append("x-key1", api_user.parse().expect("Failed to parse x-key1"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
request.metadata_mut().append(
"x-connector-request-reference-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": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6234876021404422116_75_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/elavon_payment_flows_test.rs
);
request
.metadata_mut()
.append("x-key1", api_user.parse().expect("Failed to parse x-key1"));
request.metadata_mut().append(
"x-api-secret",
api_secret.parse().expect("Failed to parse x-api-secret"),
);
request.metadata_mut().append(
"x-merchant-id",
"test_merchant"
.parse()
.expect("Failed to parse x-merchant-id"),
);
request.metadata_mut().append(
"x-tenant-id",
"default".parse().expect("Failed to parse x-tenant-id"),
);
request.metadata_mut().append(
"x-request-id",
format!("test_request_{}", get_timestamp())
.parse()
.expect("Failed to parse x-request-id"),
);
request.metadata_mut().append(
"x-connector-request-reference-id",
format!("conn_ref_{}", get_timestamp())
.parse()
.expect("Failed to parse x-connector-request-reference-id"),
);
}
// Helper function to extract connector transaction ID from response
fn extract_transaction_id(response: &PaymentServiceAuthorizeResponse) -> String {
match &response.transaction_id {
Some(id) => match id.id_type.as_ref().unwrap() {
IdType::Id(id) => id.clone(),
_ => panic!("Expected connector transaction ID"),
},
None => panic!("Resource ID is None"),
}
}
// Helper function to create a payment authorization request
fn create_payment_authorize_request(
capture_method: 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": 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
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.