id
stringlengths 20
153
| type
stringclasses 1
value | granularity
stringclasses 14
values | content
stringlengths 16
84.3k
| metadata
dict |
|---|---|---|---|---|
connector-service_snippet_6580252036373041860_0_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::panic)]
use grpc_server::{app, configs};
use hyperswitch_masking::ExposeInterface;
mod common;
mod utils;
use grpc_api_types::payments::{
payment_service_client::PaymentServiceClient,
webhook_response_content::Content as GrpcWebhookContent, DisputeStage as GrpcDisputeStage,
DisputeStatus as GrpcDisputeStatus, DisputesSyncResponse, PaymentServiceTransformRequest,
RequestDetails,
};
use serde_json::json;
use tonic::{transport::Channel, Request};
// Helper function to construct Adyen webhook JSON body
fn build_adyen_webhook_json_body(
event_code: &str,
reason: &str,
adyen_dispute_status: Option<&str>,
) -> serde_json::Value {
let mut additional_data = serde_json::Map::new();
if let Some(status) = adyen_dispute_status {
additional_data.insert("disputeStatus".to_string(), json!(status));
}
let psp_reference = "9915555555555555"; // Default
let original_reference = "9913333333333333"; // Default
let merchant_account_code = "YOUR_MERCHANT_ACCOUNT"; // Default
let merchant_reference = "YOUR_REFERENCE"; // Default
let payment_method = "mc"; // Default
let amount_currency = "EUR"; // Default
let amount_value = 1000; // Default
let event_date = "2023-12-01T12:00:00Z"; // Default
let success_status = "true";
json!({
"live": "false",
"notificationItems": [
{
"NotificationRequestItem": {
"eventCode": event_code,
"success": success_status,
"pspReference": psp_reference,
"originalReference": original_reference,
"merchantAccountCode": merchant_account_code,
"merchantReference": merchant_reference,
"paymentMethod": payment_method,
"eventDate": event_date,
"additionalData": additional_data,
"reason": reason,
|
{
"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_6580252036373041860_25_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
let psp_reference = "9915555555555555"; // Default
let original_reference = "9913333333333333"; // Default
let merchant_account_code = "YOUR_MERCHANT_ACCOUNT"; // Default
let merchant_reference = "YOUR_REFERENCE"; // Default
let payment_method = "mc"; // Default
let amount_currency = "EUR"; // Default
let amount_value = 1000; // Default
let event_date = "2023-12-01T12:00:00Z"; // Default
let success_status = "true";
json!({
"live": "false",
"notificationItems": [
{
"NotificationRequestItem": {
|
{
"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_6580252036373041860_25_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
let psp_reference = "9915555555555555"; // Default
let original_reference = "9913333333333333"; // Default
let merchant_account_code = "YOUR_MERCHANT_ACCOUNT"; // Default
let merchant_reference = "YOUR_REFERENCE"; // Default
let payment_method = "mc"; // Default
let amount_currency = "EUR"; // Default
let amount_value = 1000; // Default
let event_date = "2023-12-01T12:00:00Z"; // Default
let success_status = "true";
json!({
"live": "false",
"notificationItems": [
{
"NotificationRequestItem": {
"eventCode": event_code,
"success": success_status,
"pspReference": psp_reference,
"originalReference": original_reference,
"merchantAccountCode": merchant_account_code,
"merchantReference": merchant_reference,
"paymentMethod": payment_method,
"eventDate": event_date,
"additionalData": additional_data,
"reason": reason,
"amount": {
"value": amount_value,
"currency": amount_currency
}
}
|
{
"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_6580252036373041860_25_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
let psp_reference = "9915555555555555"; // Default
let original_reference = "9913333333333333"; // Default
let merchant_account_code = "YOUR_MERCHANT_ACCOUNT"; // Default
let merchant_reference = "YOUR_REFERENCE"; // Default
let payment_method = "mc"; // Default
let amount_currency = "EUR"; // Default
let amount_value = 1000; // Default
let event_date = "2023-12-01T12:00:00Z"; // Default
let success_status = "true";
json!({
"live": "false",
"notificationItems": [
{
"NotificationRequestItem": {
"eventCode": event_code,
"success": success_status,
"pspReference": psp_reference,
"originalReference": original_reference,
"merchantAccountCode": merchant_account_code,
"merchantReference": merchant_reference,
"paymentMethod": payment_method,
"eventDate": event_date,
"additionalData": additional_data,
"reason": reason,
"amount": {
"value": amount_value,
"currency": amount_currency
}
}
}
]
})
}
// Helper to make the gRPC call and return the DisputesSyncResponse
async fn process_webhook_and_get_response(
client: &mut PaymentServiceClient<Channel>,
json_body: serde_json::Value,
) -> DisputesSyncResponse {
let request_body_bytes =
serde_json::to_vec(&json_body).expect("Failed to serialize json_body to Vec<u8>");
let mut request = Request::new(PaymentServiceTransformRequest {
request_ref_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(
"webhook_test".to_string(),
)),
}),
request_details: Some(RequestDetails {
|
{
"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_6580252036373041860_50_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
"amount": {
"value": amount_value,
"currency": amount_currency
}
}
}
]
})
}
// Helper to make the gRPC call and return the DisputesSyncResponse
async fn process_webhook_and_get_response(
client: &mut PaymentServiceClient<Channel>,
json_body: serde_json::Value,
) -> DisputesSyncResponse {
|
{
"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_6580252036373041860_50_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
"amount": {
"value": amount_value,
"currency": amount_currency
}
}
}
]
})
}
// Helper to make the gRPC call and return the DisputesSyncResponse
async fn process_webhook_and_get_response(
client: &mut PaymentServiceClient<Channel>,
json_body: serde_json::Value,
) -> DisputesSyncResponse {
let request_body_bytes =
serde_json::to_vec(&json_body).expect("Failed to serialize json_body to Vec<u8>");
let mut request = Request::new(PaymentServiceTransformRequest {
request_ref_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(
"webhook_test".to_string(),
)),
}),
request_details: Some(RequestDetails {
method: grpc_api_types::payments::HttpMethod::Post.into(),
headers: std::collections::HashMap::new(),
uri: Some("/webhooks/adyen".to_string()),
query_params: None,
body: request_body_bytes,
|
{
"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_6580252036373041860_50_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
"amount": {
"value": amount_value,
"currency": amount_currency
}
}
}
]
})
}
// Helper to make the gRPC call and return the DisputesSyncResponse
async fn process_webhook_and_get_response(
client: &mut PaymentServiceClient<Channel>,
json_body: serde_json::Value,
) -> DisputesSyncResponse {
let request_body_bytes =
serde_json::to_vec(&json_body).expect("Failed to serialize json_body to Vec<u8>");
let mut request = Request::new(PaymentServiceTransformRequest {
request_ref_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(
"webhook_test".to_string(),
)),
}),
request_details: Some(RequestDetails {
method: grpc_api_types::payments::HttpMethod::Post.into(),
headers: std::collections::HashMap::new(),
uri: Some("/webhooks/adyen".to_string()),
query_params: None,
body: request_body_bytes,
}),
webhook_secrets: None,
state: None,
});
let auth = utils::credential_utils::load_connector_auth("adyen")
.expect("Failed to load adyen 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 adyen"),
};
request.metadata_mut().append(
"x-connector",
"adyen".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": 50,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_75_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
method: grpc_api_types::payments::HttpMethod::Post.into(),
headers: std::collections::HashMap::new(),
uri: Some("/webhooks/adyen".to_string()),
query_params: None,
body: request_body_bytes,
}),
webhook_secrets: None,
state: None,
});
let auth = utils::credential_utils::load_connector_auth("adyen")
.expect("Failed to load adyen credentials");
let (api_key, key1, api_secret) = match auth {
domain_types::router_data::ConnectorAuthType::SignatureKey {
|
{
"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_6580252036373041860_75_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
method: grpc_api_types::payments::HttpMethod::Post.into(),
headers: std::collections::HashMap::new(),
uri: Some("/webhooks/adyen".to_string()),
query_params: None,
body: request_body_bytes,
}),
webhook_secrets: None,
state: None,
});
let auth = utils::credential_utils::load_connector_auth("adyen")
.expect("Failed to load adyen 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 adyen"),
};
request.metadata_mut().append(
"x-connector",
"adyen".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": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_75_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
method: grpc_api_types::payments::HttpMethod::Post.into(),
headers: std::collections::HashMap::new(),
uri: Some("/webhooks/adyen".to_string()),
query_params: None,
body: request_body_bytes,
}),
webhook_secrets: None,
state: None,
});
let auth = utils::credential_utils::load_connector_auth("adyen")
.expect("Failed to load adyen 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 adyen"),
};
request.metadata_mut().append(
"x-connector",
"adyen".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"),
);
let response = client
.transform(request)
.await
.expect("gRPC transform call failed")
.into_inner();
match response.content.and_then(|c| c.content) {
Some(GrpcWebhookContent::DisputesResponse(dispute_response)) => {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 75,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_100_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_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": 100,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_100_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_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"),
);
let response = client
.transform(request)
.await
.expect("gRPC transform call failed")
.into_inner();
match response.content.and_then(|c| c.content) {
Some(GrpcWebhookContent::DisputesResponse(dispute_response)) => {
DisputesSyncResponse {
stage: dispute_response.dispute_stage,
status: dispute_response.dispute_status,
dispute_message: dispute_response.dispute_message,
dispute_id: dispute_response.dispute_id.unwrap_or("".to_string()), // TODO need a fix
|
{
"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_6580252036373041860_100_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_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"),
);
let response = client
.transform(request)
.await
.expect("gRPC transform call failed")
.into_inner();
match response.content.and_then(|c| c.content) {
Some(GrpcWebhookContent::DisputesResponse(dispute_response)) => {
DisputesSyncResponse {
stage: dispute_response.dispute_stage,
status: dispute_response.dispute_status,
dispute_message: dispute_response.dispute_message,
dispute_id: dispute_response.dispute_id.unwrap_or("".to_string()), // TODO need a fix
connector_response_reference_id: None, // TODO need a fix
}
}
_ => {
//if the content is not a DisputesResponse, return a dummy DisputesSyncResponse
DisputesSyncResponse {
stage: 0,
status: 0,
dispute_message: None,
dispute_id: "".to_string(),
connector_response_reference_id: None,
}
}
}
}
// --- Test Cases ---
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_undefended() {
|
{
"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_6580252036373041860_125_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
DisputesSyncResponse {
stage: dispute_response.dispute_stage,
status: dispute_response.dispute_status,
dispute_message: dispute_response.dispute_message,
dispute_id: dispute_response.dispute_id.unwrap_or("".to_string()), // TODO need a fix
connector_response_reference_id: None, // TODO need a fix
}
}
_ => {
//if the content is not a DisputesResponse, return a dummy DisputesSyncResponse
DisputesSyncResponse {
stage: 0,
status: 0,
dispute_message: None,
dispute_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": 125,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_125_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
DisputesSyncResponse {
stage: dispute_response.dispute_stage,
status: dispute_response.dispute_status,
dispute_message: dispute_response.dispute_message,
dispute_id: dispute_response.dispute_id.unwrap_or("".to_string()), // TODO need a fix
connector_response_reference_id: None, // TODO need a fix
}
}
_ => {
//if the content is not a DisputesResponse, return a dummy DisputesSyncResponse
DisputesSyncResponse {
stage: 0,
status: 0,
dispute_message: None,
dispute_id: "".to_string(),
connector_response_reference_id: None,
}
}
}
}
// --- Test Cases ---
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_undefended() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Fraudulent transaction";
let adyen_dispute_status = Some("Undefended");
|
{
"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_6580252036373041860_125_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
DisputesSyncResponse {
stage: dispute_response.dispute_stage,
status: dispute_response.dispute_status,
dispute_message: dispute_response.dispute_message,
dispute_id: dispute_response.dispute_id.unwrap_or("".to_string()), // TODO need a fix
connector_response_reference_id: None, // TODO need a fix
}
}
_ => {
//if the content is not a DisputesResponse, return a dummy DisputesSyncResponse
DisputesSyncResponse {
stage: 0,
status: 0,
dispute_message: None,
dispute_id: "".to_string(),
connector_response_reference_id: None,
}
}
}
}
// --- Test Cases ---
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_undefended() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Fraudulent transaction";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
grpc_api_types::payments::DisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
grpc_api_types::payments::DisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_pending() {
|
{
"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_6580252036373041860_150_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Fraudulent transaction";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
grpc_api_types::payments::DisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
grpc_api_types::payments::DisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_150_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Fraudulent transaction";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
grpc_api_types::payments::DisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
grpc_api_types::payments::DisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Product not received";
let adyen_dispute_status = Some("Pending");
|
{
"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_6580252036373041860_150_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Fraudulent transaction";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
grpc_api_types::payments::DisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
grpc_api_types::payments::DisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#notification_of_chargeback
#[tokio::test]
async fn test_notification_of_chargeback_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Product not received";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_undefended() {
|
{
"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_6580252036373041860_175_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Product not received";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_175_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Product not received";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_undefended() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Service not rendered";
let adyen_dispute_status = Some("Undefended");
|
{
"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_6580252036373041860_175_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "NOTIFICATION_OF_CHARGEBACK";
let reason = "Product not received";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_undefended() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Service not rendered";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_pending() {
|
{
"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_6580252036373041860_200_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Service not rendered";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 200,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_200_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Service not rendered";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Credit not processed";
let adyen_dispute_status = Some("Pending");
|
{
"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_6580252036373041860_200_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Service not rendered";
let adyen_dispute_status = Some("Undefended");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Credit not processed";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_lost() {
|
{
"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_6580252036373041860_225_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Credit not processed";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_225_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Credit not processed";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Duplicate transaction";
let adyen_dispute_status = Some("Lost");
|
{
"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_6580252036373041860_225_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Credit not processed";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Duplicate transaction";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_accepted() {
|
{
"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_6580252036373041860_250_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Duplicate transaction";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_250_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Duplicate transaction";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_accepted() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Fraudulent transaction - merchant accepted";
let adyen_dispute_status = Some("Accepted");
|
{
"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_6580252036373041860_250_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Duplicate transaction";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback
#[tokio::test]
async fn test_chargeback_accepted() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Fraudulent transaction - merchant accepted";
let adyen_dispute_status = Some("Accepted");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeAccepted
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_pending() {
|
{
"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_6580252036373041860_275_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Fraudulent transaction - merchant accepted";
let adyen_dispute_status = Some("Accepted");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_275_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Fraudulent transaction - merchant accepted";
let adyen_dispute_status = Some("Accepted");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeAccepted
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense successful, awaiting bank review";
let adyen_dispute_status = Some("Pending");
|
{
"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_6580252036373041860_275_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK";
let reason = "Fraudulent transaction - merchant accepted";
let adyen_dispute_status = Some("Accepted");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeAccepted
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense successful, awaiting bank review";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeChallenged
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_won() {
|
{
"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_6580252036373041860_300_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense successful, awaiting bank review";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_300_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense successful, awaiting bank review";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeChallenged
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_won() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense accepted by bank";
let adyen_dispute_status = Some("Won");
|
{
"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_6580252036373041860_300_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense successful, awaiting bank review";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeChallenged
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#chargeback_reversed
#[tokio::test]
async fn test_chargeback_reversed_won() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense accepted by bank";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#second_chargeback
#[tokio::test]
async fn test_second_chargeback_lost() {
|
{
"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_6580252036373041860_325_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense accepted by bank";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_325_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense accepted by bank";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#second_chargeback
#[tokio::test]
async fn test_second_chargeback_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "SECOND_CHARGEBACK";
let reason = "Defense declined after initial reversal";
let adyen_dispute_status = Some("Lost");
|
{
"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_6580252036373041860_325_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "CHARGEBACK_REVERSED";
let reason = "Defense accepted by bank";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::ActiveDispute
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#second_chargeback
#[tokio::test]
async fn test_second_chargeback_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "SECOND_CHARGEBACK";
let reason = "Defense declined after initial reversal";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_won() {
|
{
"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_6580252036373041860_350_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "SECOND_CHARGEBACK";
let reason = "Defense declined after initial reversal";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_350_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "SECOND_CHARGEBACK";
let reason = "Defense declined after initial reversal";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_won() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration won by merchant";
let adyen_dispute_status = Some("Won");
|
{
"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_6580252036373041860_350_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "SECOND_CHARGEBACK";
let reason = "Defense declined after initial reversal";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_won() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration won by merchant";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_pending() {
|
{
"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_6580252036373041860_375_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration won by merchant";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 375,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_375_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration won by merchant";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration outcome pending";
let adyen_dispute_status = Some("Pending");
|
{
"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_6580252036373041860_375_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration won by merchant";
let adyen_dispute_status = Some("Won");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeWon
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_won
#[tokio::test]
async fn test_prearbitration_won_with_status_pending() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration outcome pending";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_lost
#[tokio::test]
async fn test_prearbitration_lost() {
|
{
"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_6580252036373041860_400_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration outcome pending";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_400_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration outcome pending";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_lost
#[tokio::test]
async fn test_prearbitration_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_LOST";
let reason = "Pre-arbitration lost by merchant";
let adyen_dispute_status = Some("Lost");
|
{
"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_6580252036373041860_400_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_WON";
let reason = "Pre-arbitration outcome pending";
let adyen_dispute_status = Some("Pending");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeOpened
);
assert_eq!(dispute_response.dispute_message, Some(reason.to_string()));
});
}
// Adyen Doc: https://docs.adyen.com/risk-management/disputes-api/dispute-notifications/#prearbitration_lost
#[tokio::test]
async fn test_prearbitration_lost() {
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_LOST";
let reason = "Pre-arbitration lost by merchant";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.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": 46,
"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_6580252036373041860_425_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_LOST";
let reason = "Pre-arbitration lost by merchant";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.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": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_6580252036373041860_425_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_LOST";
let reason = "Pre-arbitration lost by merchant";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.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": 21,
"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_6580252036373041860_425_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/adyen_dispute_webhook_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
let event_code = "PREARBITRATION_LOST";
let reason = "Pre-arbitration lost by merchant";
let adyen_dispute_status = Some("Lost");
let json_body = build_adyen_webhook_json_body(event_code, reason, adyen_dispute_status);
let dispute_response = process_webhook_and_get_response(&mut client, json_body).await;
assert_eq!(
GrpcDisputeStage::try_from(dispute_response.stage)
.expect("Failed to convert i32 to DisputeStage"),
GrpcDisputeStage::PreArbitration
);
assert_eq!(
GrpcDisputeStatus::try_from(dispute_response.status)
.expect("Failed to convert i32 to DisputeStatus"),
GrpcDisputeStatus::DisputeLost
);
assert_eq!(dispute_response.dispute_message, Some(reason.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": 21,
"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_3350236631919853906_0_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use cards::CardNumber;
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
|
{
"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_3350236631919853906_0_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use cards::CardNumber;
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
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,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use tonic::{transport::Channel, Request};
// Constants for Checkout connector
const CONNECTOR_NAME: &str = "checkout";
|
{
"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_3350236631919853906_0_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)]
#![allow(clippy::panic)]
use cards::CardNumber;
use grpc_server::{app, configs};
use hyperswitch_masking::{ExposeInterface, Secret};
mod common;
mod utils;
use std::{
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
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,
PaymentServiceVoidRequest, PaymentStatus, RefundServiceGetRequest, RefundStatus,
},
};
use tonic::{transport::Channel, Request};
// Constants for Checkout connector
const CONNECTOR_NAME: &str = "checkout";
const AUTH_TYPE: &str = "signature-key";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const AUTO_CAPTURE_CARD_NUMBER: &str = "4000020000000000"; // Card number from checkout_grpcurl_test.sh for auto capture
const MANUAL_CAPTURE_CARD_NUMBER: &str = "4242424242424242"; // Card number from checkout_grpcurl_test.sh for manual capture
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "100";
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_3350236631919853906_25_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
};
use tonic::{transport::Channel, Request};
// Constants for Checkout connector
const CONNECTOR_NAME: &str = "checkout";
const AUTH_TYPE: &str = "signature-key";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const AUTO_CAPTURE_CARD_NUMBER: &str = "4000020000000000"; // Card number from checkout_grpcurl_test.sh for auto capture
const MANUAL_CAPTURE_CARD_NUMBER: &str = "4242424242424242"; // Card number from checkout_grpcurl_test.sh for manual capture
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "100";
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_3350236631919853906_25_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
};
use tonic::{transport::Channel, Request};
// Constants for Checkout connector
const CONNECTOR_NAME: &str = "checkout";
const AUTH_TYPE: &str = "signature-key";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const AUTO_CAPTURE_CARD_NUMBER: &str = "4000020000000000"; // Card number from checkout_grpcurl_test.sh for auto capture
const MANUAL_CAPTURE_CARD_NUMBER: &str = "4242424242424242"; // Card number from checkout_grpcurl_test.sh for manual capture
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "100";
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 checkout metadata headers to a request
fn add_checkout_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load checkout 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_3350236631919853906_25_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
};
use tonic::{transport::Channel, Request};
// Constants for Checkout connector
const CONNECTOR_NAME: &str = "checkout";
const AUTH_TYPE: &str = "signature-key";
// Test card data
const TEST_AMOUNT: i64 = 1000;
const AUTO_CAPTURE_CARD_NUMBER: &str = "4000020000000000"; // Card number from checkout_grpcurl_test.sh for auto capture
const MANUAL_CAPTURE_CARD_NUMBER: &str = "4242424242424242"; // Card number from checkout_grpcurl_test.sh for manual capture
const TEST_CARD_EXP_MONTH: &str = "12";
const TEST_CARD_EXP_YEAR: &str = "2025";
const TEST_CARD_CVC: &str = "100";
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 checkout metadata headers to a request
fn add_checkout_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load checkout 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 checkout"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request
.metadata_mut()
.append("x-auth", AUTH_TYPE.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_3350236631919853906_50_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Helper function to add checkout metadata headers to a request
fn add_checkout_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load checkout 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 checkout"),
};
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_3350236631919853906_50_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Helper function to add checkout metadata headers to a request
fn add_checkout_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load checkout 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 checkout"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request
.metadata_mut()
.append("x-auth", AUTH_TYPE.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",
|
{
"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_3350236631919853906_50_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Helper function to add checkout metadata headers to a request
fn add_checkout_metadata<T>(request: &mut Request<T>) {
let auth = utils::credential_utils::load_connector_auth(CONNECTOR_NAME)
.expect("Failed to load checkout 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 checkout"),
};
request.metadata_mut().append(
"x-connector",
CONNECTOR_NAME.parse().expect("Failed to parse x-connector"),
);
request
.metadata_mut()
.append("x-auth", AUTH_TYPE.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"),
);
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"),
|
{
"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_3350236631919853906_75_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
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"),
);
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_3350236631919853906_75_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
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"),
);
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())
|
{
"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_3350236631919853906_75_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
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"),
);
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,
) -> PaymentServiceAuthorizeRequest {
|
{
"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_3350236631919853906_100_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
);
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(),
|
{
"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_3350236631919853906_100_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
);
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 {
// Select the correct card number based on capture method
let card_number = match capture_method {
CaptureMethod::Automatic => Some(CardNumber::from_str(AUTO_CAPTURE_CARD_NUMBER).unwrap()),
CaptureMethod::Manual => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()),
_ => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()), // Default to manual capture card
|
{
"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_3350236631919853906_100_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
);
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 {
// Select the correct card number based on capture method
let card_number = match capture_method {
CaptureMethod::Automatic => Some(CardNumber::from_str(AUTO_CAPTURE_CARD_NUMBER).unwrap()),
CaptureMethod::Manual => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()),
_ => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()), // Default to manual capture card
};
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number,
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,
|
{
"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_3350236631919853906_125_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Select the correct card number based on capture method
let card_number = match capture_method {
CaptureMethod::Automatic => Some(CardNumber::from_str(AUTO_CAPTURE_CARD_NUMBER).unwrap()),
CaptureMethod::Manual => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()),
_ => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()), // Default to manual capture card
};
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number,
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,
|
{
"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_3350236631919853906_125_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Select the correct card number based on capture method
let card_number = match capture_method {
CaptureMethod::Automatic => Some(CardNumber::from_str(AUTO_CAPTURE_CARD_NUMBER).unwrap()),
CaptureMethod::Manual => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()),
_ => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()), // Default to manual capture card
};
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number,
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),
})),
|
{
"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_3350236631919853906_125_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Select the correct card number based on capture method
let card_number = match capture_method {
CaptureMethod::Automatic => Some(CardNumber::from_str(AUTO_CAPTURE_CARD_NUMBER).unwrap()),
CaptureMethod::Manual => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()),
_ => Some(CardNumber::from_str(MANUAL_CAPTURE_CARD_NUMBER).unwrap()), // Default to manual capture card
};
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number,
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),
})),
}),
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!("checkout_test_{}", get_timestamp()))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
metadata: std::collections::HashMap::new(),
..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())),
|
{
"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_3350236631919853906_150_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
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!("checkout_test_{}", get_timestamp()))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
|
{
"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_3350236631919853906_150_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
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!("checkout_test_{}", get_timestamp()))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
metadata: std::collections::HashMap::new(),
..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!("checkout_sync_{}", get_timestamp()))),
}),
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": 150,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_150_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
currency: i32::from(Currency::Usd),
payment_method: Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
}),
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!("checkout_test_{}", get_timestamp()))),
}),
enrolled_for_3ds: false,
request_incremental_authorization: false,
capture_method: Some(i32::from(capture_method)),
metadata: std::collections::HashMap::new(),
..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!("checkout_sync_{}", get_timestamp()))),
}),
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 {
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: std::collections::HashMap::new(),
request_ref_id: 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": 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_3350236631919853906_175_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("checkout_sync_{}", get_timestamp()))),
}),
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 {
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": 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_3350236631919853906_175_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("checkout_sync_{}", get_timestamp()))),
}),
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 {
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: std::collections::HashMap::new(),
request_ref_id: None,
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a refund 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": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_175_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}),
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("checkout_sync_{}", get_timestamp()))),
}),
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 {
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: std::collections::HashMap::new(),
request_ref_id: None,
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
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,
reason: Some("Test refund".to_string()),
webhook_url: None,
metadata: std::collections::HashMap::new(),
refund_metadata: std::collections::HashMap::new(),
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None,
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": 175,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_200_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
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,
|
{
"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_3350236631919853906_200_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
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,
reason: Some("Test refund".to_string()),
webhook_url: None,
metadata: std::collections::HashMap::new(),
refund_metadata: std::collections::HashMap::new(),
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: None,
state: None,
}
}
// Helper function to create a refund sync request
fn create_refund_sync_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
|
{
"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_3350236631919853906_200_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
state: None,
}
}
// Helper function to create a refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
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,
reason: Some("Test refund".to_string()),
webhook_url: None,
metadata: std::collections::HashMap::new(),
refund_metadata: std::collections::HashMap::new(),
browser_info: None,
merchant_account_id: None,
capture_method: None,
request_ref_id: 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,
browser_info: None,
refund_metadata: std::collections::HashMap::new(),
state: None,
}
}
// Helper function to sleep for a short duration to allow server processing
fn allow_processing_time() {
std::thread::sleep(std::time::Duration::from_secs(3));
}
// Helper function to create a payment void request
fn create_payment_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 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_3350236631919853906_225_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}
}
// 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,
browser_info: None,
refund_metadata: std::collections::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": 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_3350236631919853906_225_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}
}
// 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,
browser_info: None,
refund_metadata: std::collections::HashMap::new(),
state: None,
}
}
// Helper function to sleep for a short duration to allow server processing
fn allow_processing_time() {
std::thread::sleep(std::time::Duration::from_secs(3));
}
// Helper function to create a payment void request
fn create_payment_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: 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": 225,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_225_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
}
}
// 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,
browser_info: None,
refund_metadata: std::collections::HashMap::new(),
state: None,
}
}
// Helper function to sleep for a short duration to allow server processing
fn allow_processing_time() {
std::thread::sleep(std::time::Duration::from_secs(3));
}
// Helper function to create a payment void request
fn create_payment_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("void_ref_{}", get_timestamp()))),
}),
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
// 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
|
{
"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_3350236631919853906_250_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("void_ref_{}", get_timestamp()))),
}),
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 250,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_250_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("void_ref_{}", get_timestamp()))),
}),
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
// 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(),
|
{
"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_3350236631919853906_250_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
PaymentServiceVoidRequest {
transaction_id: Some(Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
}),
cancellation_reason: None,
request_ref_id: Some(Identifier {
id_type: Some(IdType::Id(format!("void_ref_{}", get_timestamp()))),
}),
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
// 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_checkout_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 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_3350236631919853906_275_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.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
|
{
"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_3350236631919853906_275_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.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_checkout_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Verify the response
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": 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_3350236631919853906_275_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.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_checkout_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Verify the response
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&response);
// Verify payment status - for automatic capture, should be PENDING according to our implementation
assert!(
response.status == i32::from(PaymentStatus::Pending),
"Payment should be in PENDING state for automatic capture before sync"
);
// Wait longer for the transaction to be fully processed
std::thread::sleep(std::time::Duration::from_secs(10));
// Create sync request with the transaction ID
let sync_request = create_payment_sync_request(&transaction_id);
// Add metadata headers for 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": 275,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_300_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.expect("gRPC payment_authorize call failed")
.into_inner();
// Verify the response
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&response);
// Verify payment status - for automatic capture, should be PENDING according to our implementation
assert!(
response.status == i32::from(PaymentStatus::Pending),
|
{
"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_3350236631919853906_300_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.expect("gRPC payment_authorize call failed")
.into_inner();
// Verify the response
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&response);
// Verify payment status - for automatic capture, should be PENDING according to our implementation
assert!(
response.status == i32::from(PaymentStatus::Pending),
"Payment should be in PENDING state for automatic capture before sync"
);
// Wait longer for the transaction to be fully processed
std::thread::sleep(std::time::Duration::from_secs(10));
// Create sync request with the transaction ID
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_checkout_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": 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_3350236631919853906_300_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
.expect("gRPC payment_authorize call failed")
.into_inner();
// Verify the response
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&response);
// Verify payment status - for automatic capture, should be PENDING according to our implementation
assert!(
response.status == i32::from(PaymentStatus::Pending),
"Payment should be in PENDING state for automatic capture before sync"
);
// Wait longer for the transaction to be fully processed
std::thread::sleep(std::time::Duration::from_secs(10));
// Create sync request with the transaction ID
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_checkout_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();
// After the sync, payment should be in CHARGED state based on connector_meta with Capture intent
assert_eq!(
sync_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after sync with Capture intent"
);
});
}
// 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);
|
{
"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_3350236631919853906_325_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
let mut sync_grpc_request = Request::new(sync_request);
add_checkout_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();
// After the sync, payment should be in CHARGED state based on connector_meta with Capture intent
assert_eq!(
sync_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after sync with Capture intent"
|
{
"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_3350236631919853906_325_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
let mut sync_grpc_request = Request::new(sync_request);
add_checkout_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();
// After the sync, payment should be in CHARGED state based on connector_meta with Capture intent
assert_eq!(
sync_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after sync with Capture intent"
);
});
}
// 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_checkout_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": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_325_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
let mut sync_grpc_request = Request::new(sync_request);
add_checkout_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();
// After the sync, payment should be in CHARGED state based on connector_meta with Capture intent
assert_eq!(
sync_response.status,
i32::from(PaymentStatus::Charged),
"Payment should be in CHARGED state after sync with Capture intent"
);
});
}
// 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_checkout_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(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture, as per our implementation)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture (Authorize intent)"
);
|
{
"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_3350236631919853906_350_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_checkout_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(),
"Transaction ID should be present"
|
{
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_350_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_checkout_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(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture, as per our implementation)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture (Authorize intent)"
);
// Create capture request
let capture_request = create_payment_capture_request(&transaction_id);
// Add metadata headers for capture 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": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
}
|
connector-service_snippet_3350236631919853906_350_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_checkout_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(),
"Transaction ID should be present"
);
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture, as per our implementation)
assert!(
auth_response.status == i32::from(PaymentStatus::Authorized),
"Payment should be in AUTHORIZED state with manual capture (Authorize intent)"
);
// Create capture request
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_checkout_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC payment_capture call failed")
.into_inner();
// 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]
|
{
"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_3350236631919853906_375_15
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Create capture request
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_checkout_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC payment_capture 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": 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_3350236631919853906_375_30
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Create capture request
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_checkout_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC payment_capture call failed")
.into_inner();
// 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::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": 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_3350236631919853906_375_50
|
clm
|
snippet
|
// connector-service/backend/grpc-server/tests/beta_tests/checkout_payment_flows_test.rs
// Create capture request
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_checkout_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_response = client
.capture(capture_grpc_request)
.await
.expect("gRPC payment_capture call failed")
.into_inner();
// 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::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_checkout_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);
// Wait longer for the transaction to be processed - some async processing may happen
std::thread::sleep(std::time::Duration::from_secs(5));
// Create sync request with the specific transaction ID
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": 375,
"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.