id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_snippet_7957748028931523727_300_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(2_i32), // Mastercard network for 5123456789012346
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
request.customer_id = Some("TEST_CONNECTOR".to_string());
// Set the customer information with unique email
request.email = Some(generate_unique_email().into());
// Generate random names for billing to prevent duplicate transaction errors
let billing_first_name = random_name();
let billing_last_name = random_name();
// Minimal address structure matching working grpcurl
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some(billing_first_name.into()),
last_name: Some(billing_last_name.into()),
line1: Some("14 Main Street".to_string().into()),
line2: None,
line3: None,
city: Some("Pecan Springs".to_string().into()),
state: Some("TX".to_string().into()),
zip_code: Some("44628".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: None,
}),
shipping_address: None, // Minimal address - no shipping for working grpcurl
});
let browser_info = BrowserInformation {
color_depth: None,
java_enabled: Some(false),
screen_height: Some(1080),
screen_width: Some(1920),
user_agent: Some("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)".to_string()),
accept_header: Some(
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8".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": 300,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_325_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
billing_address: Some(Address {
first_name: Some(billing_first_name.into()),
last_name: Some(billing_last_name.into()),
line1: Some("14 Main Street".to_string().into()),
line2: None,
line3: None,
city: Some("Pecan Springs".to_string().into()),
state: Some("TX".to_string().into()),
zip_code: Some("44628".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: None,
}),
shipping_address: None, // Minimal address - no shipping for working grpcurl
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_325_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
billing_address: Some(Address {
first_name: Some(billing_first_name.into()),
last_name: Some(billing_last_name.into()),
line1: Some("14 Main Street".to_string().into()),
line2: None,
line3: None,
city: Some("Pecan Springs".to_string().into()),
state: Some("TX".to_string().into()),
zip_code: Some("44628".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: None,
}),
shipping_address: None, // Minimal address - no shipping for working grpcurl
});
let browser_info = BrowserInformation {
color_depth: None,
java_enabled: Some(false),
screen_height: Some(1080),
screen_width: Some(1920),
user_agent: Some("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)".to_string()),
accept_header: Some(
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8".to_string(),
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
referer: None,
ip_address: 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": 325,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_325_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
billing_address: Some(Address {
first_name: Some(billing_first_name.into()),
last_name: Some(billing_last_name.into()),
line1: Some("14 Main Street".to_string().into()),
line2: None,
line3: None,
city: Some("Pecan Springs".to_string().into()),
state: Some("TX".to_string().into()),
zip_code: Some("44628".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: None,
}),
shipping_address: None, // Minimal address - no shipping for working grpcurl
});
let browser_info = BrowserInformation {
color_depth: None,
java_enabled: Some(false),
screen_height: Some(1080),
screen_width: Some(1920),
user_agent: Some("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)".to_string()),
accept_header: Some(
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8".to_string(),
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
referer: None,
ip_address: None,
os_type: None,
os_version: None,
device_model: None,
accept_language: None,
time_zone_offset_minutes: None,
};
request.browser_info = Some(browser_info);
request.return_url = Some("www.google.com".to_string());
// Set the transaction details
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
request.request_incremental_authorization = true;
request.enrolled_for_3ds = true;
// Set capture method
if let common_enums::CaptureMethod::Manual = capture_method {
request.capture_method = Some(i32::from(CaptureMethod::Manual));
// request.request_incremental_authorization = true;
| {
"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_7957748028931523727_350_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
referer: None,
ip_address: None,
os_type: None,
os_version: None,
device_model: None,
accept_language: None,
time_zone_offset_minutes: None,
};
request.browser_info = Some(browser_info);
request.return_url = Some("www.google.com".to_string());
// Set the transaction details
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_350_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
referer: None,
ip_address: None,
os_type: None,
os_version: None,
device_model: None,
accept_language: None,
time_zone_offset_minutes: None,
};
request.browser_info = Some(browser_info);
request.return_url = Some("www.google.com".to_string());
// Set the transaction details
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
request.request_incremental_authorization = true;
request.enrolled_for_3ds = true;
// Set capture method
if let common_enums::CaptureMethod::Manual = capture_method {
request.capture_method = Some(i32::from(CaptureMethod::Manual));
// request.request_incremental_authorization = true;
} else {
request.capture_method = Some(i32::from(CaptureMethod::Automatic));
}
// Set the connector metadata (Base64 encoded)
| {
"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_7957748028931523727_350_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
referer: None,
ip_address: None,
os_type: None,
os_version: None,
device_model: None,
accept_language: None,
time_zone_offset_minutes: None,
};
request.browser_info = Some(browser_info);
request.return_url = Some("www.google.com".to_string());
// Set the transaction details
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
request.request_incremental_authorization = true;
request.enrolled_for_3ds = true;
// Set capture method
if let common_enums::CaptureMethod::Manual = capture_method {
request.capture_method = Some(i32::from(CaptureMethod::Manual));
// request.request_incremental_authorization = true;
} else {
request.capture_method = Some(i32::from(CaptureMethod::Automatic));
}
// Set the connector metadata (Base64 encoded)
let mut metadata = HashMap::new();
metadata.insert("metadata".to_string(), BASE64_METADATA.to_string());
request.metadata = metadata;
request
}
// Helper function to create a payment sync request
fn create_payment_get_request(transaction_id: &str) -> PaymentServiceGetRequest {
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceGetRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_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": 350,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_375_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
} else {
request.capture_method = Some(i32::from(CaptureMethod::Automatic));
}
// Set the connector metadata (Base64 encoded)
let mut metadata = HashMap::new();
metadata.insert("metadata".to_string(), BASE64_METADATA.to_string());
request.metadata = metadata;
request
}
// Helper function to create a payment sync request
fn create_payment_get_request(transaction_id: &str) -> PaymentServiceGetRequest {
let transaction_id_obj = Identifier {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 375,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_375_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
} else {
request.capture_method = Some(i32::from(CaptureMethod::Automatic));
}
// Set the connector metadata (Base64 encoded)
let mut metadata = HashMap::new();
metadata.insert("metadata".to_string(), BASE64_METADATA.to_string());
request.metadata = metadata;
request
}
// Helper function to create a payment sync request
fn create_payment_get_request(transaction_id: &str) -> PaymentServiceGetRequest {
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceGetRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_id),
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: 146, // Currency value from working grpcurl
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": 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_7957748028931523727_375_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
} else {
request.capture_method = Some(i32::from(CaptureMethod::Automatic));
}
// Set the connector metadata (Base64 encoded)
let mut metadata = HashMap::new();
metadata.insert("metadata".to_string(), BASE64_METADATA.to_string());
request.metadata = metadata;
request
}
// Helper function to create a payment sync request
fn create_payment_get_request(transaction_id: &str) -> PaymentServiceGetRequest {
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceGetRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_id),
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: 146, // Currency value from working grpcurl
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("capture"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceCaptureRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata: HashMap::new(),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 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_7957748028931523727_400_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: 146, // Currency value from working grpcurl
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("capture"))),
};
let transaction_id_obj = Identifier {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_400_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: 146, // Currency value from working grpcurl
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("capture"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceCaptureRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata: HashMap::new(),
browser_info: None,
capture_method: 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": 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_7957748028931523727_400_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
capture_method: None,
handle_response: None,
amount: TEST_AMOUNT,
currency: 146, // Currency value from working grpcurl
state: None,
}
}
// Helper function to create a payment capture request
fn create_payment_capture_request(transaction_id: &str) -> PaymentServiceCaptureRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("capture"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceCaptureRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
amount_to_capture: TEST_AMOUNT,
currency: i32::from(Currency::Usd),
multiple_capture_data: None,
connector_metadata: HashMap::new(),
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a void request
fn create_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceVoidRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_id),
cancellation_reason: None,
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": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 400,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_425_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a void request
fn create_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_425_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a void request
fn create_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceVoidRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_id),
cancellation_reason: None,
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
// Helper function to sleep for a short duration to allow server processing
fn allow_processing_time() {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_425_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
browser_info: None,
capture_method: None,
state: None,
}
}
// Helper function to create a void request
fn create_void_request(transaction_id: &str) -> PaymentServiceVoidRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
PaymentServiceVoidRequest {
transaction_id: Some(transaction_id_obj),
request_ref_id: Some(request_ref_id),
cancellation_reason: None,
all_keys_required: None,
browser_info: None,
amount: None,
currency: None,
..Default::default()
}
}
// 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 refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
// Create refund metadata with credit card information as required by Authorize.net
let mut refund_metadata = HashMap::new();
refund_metadata.insert(
"refund_metadata".to_string(),
format!(
"{{\"creditCard\":{{\"cardNumber\":\"{TEST_CARD_NUMBER}\",\"expirationDate\":\"2025-12\"}}}}",
),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 425,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_450_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
}
// 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 refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund"))),
};
let transaction_id_obj = Identifier {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_450_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
}
// 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 refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
// Create refund metadata with credit card information as required by Authorize.net
let mut refund_metadata = HashMap::new();
refund_metadata.insert(
"refund_metadata".to_string(),
format!(
"{{\"creditCard\":{{\"cardNumber\":\"{TEST_CARD_NUMBER}\",\"expirationDate\":\"2025-12\"}}}}",
),
);
PaymentServiceRefundRequest {
request_ref_id: Some(request_ref_id),
refund_id: generate_unique_request_ref_id("refund_id"),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_450_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
}
// 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 refund request
fn create_refund_request(transaction_id: &str) -> PaymentServiceRefundRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
// Create refund metadata with credit card information as required by Authorize.net
let mut refund_metadata = HashMap::new();
refund_metadata.insert(
"refund_metadata".to_string(),
format!(
"{{\"creditCard\":{{\"cardNumber\":\"{TEST_CARD_NUMBER}\",\"expirationDate\":\"2025-12\"}}}}",
),
);
PaymentServiceRefundRequest {
request_ref_id: Some(request_ref_id),
refund_id: generate_unique_request_ref_id("refund_id"),
transaction_id: Some(transaction_id_obj),
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,
merchant_account_id: None,
capture_method: None,
metadata: HashMap::new(),
refund_metadata,
browser_info: None,
state: None,
}
}
// Helper function to create a refund get request
fn create_refund_get_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
let request_ref_id = Identifier {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 450,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_475_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
PaymentServiceRefundRequest {
request_ref_id: Some(request_ref_id),
refund_id: generate_unique_request_ref_id("refund_id"),
transaction_id: Some(transaction_id_obj),
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,
merchant_account_id: None,
capture_method: None,
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_475_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
PaymentServiceRefundRequest {
request_ref_id: Some(request_ref_id),
refund_id: generate_unique_request_ref_id("refund_id"),
transaction_id: Some(transaction_id_obj),
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,
merchant_account_id: None,
capture_method: None,
metadata: HashMap::new(),
refund_metadata,
browser_info: None,
state: None,
}
}
// Helper function to create a refund get request
fn create_refund_get_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund_get"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_475_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
PaymentServiceRefundRequest {
request_ref_id: Some(request_ref_id),
refund_id: generate_unique_request_ref_id("refund_id"),
transaction_id: Some(transaction_id_obj),
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,
merchant_account_id: None,
capture_method: None,
metadata: HashMap::new(),
refund_metadata,
browser_info: None,
state: None,
}
}
// Helper function to create a refund get request
fn create_refund_get_request(transaction_id: &str, refund_id: &str) -> RefundServiceGetRequest {
let request_ref_id = Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund_get"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
RefundServiceGetRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
refund_id: refund_id.to_string(),
browser_info: None,
refund_reason: None,
refund_metadata: HashMap::new(),
state: None,
}
}
// Helper function to create a register (setup mandate) request (matching your JSON format)
#[allow(clippy::field_reassign_with_default)]
fn create_register_request() -> PaymentServiceRegisterRequest {
let mut request = PaymentServiceRegisterRequest::default();
// Set amounts matching your JSON (3000 minor units)
request.minor_amount = Some(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": 475,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_500_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund_get"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
RefundServiceGetRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
refund_id: refund_id.to_string(),
browser_info: None,
refund_reason: None,
refund_metadata: HashMap::new(),
state: None,
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_500_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund_get"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
RefundServiceGetRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
refund_id: refund_id.to_string(),
browser_info: None,
refund_reason: None,
refund_metadata: HashMap::new(),
state: None,
}
}
// Helper function to create a register (setup mandate) request (matching your JSON format)
#[allow(clippy::field_reassign_with_default)]
fn create_register_request() -> PaymentServiceRegisterRequest {
let mut request = PaymentServiceRegisterRequest::default();
// Set amounts matching your JSON (3000 minor units)
request.minor_amount = Some(TEST_AMOUNT);
request.currency = i32::from(Currency::Usd);
// Set up card payment method with Visa network as in your JSON
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_500_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
id_type: Some(IdType::Id(generate_unique_request_ref_id("refund_get"))),
};
let transaction_id_obj = Identifier {
id_type: Some(IdType::Id(transaction_id.to_string())),
};
RefundServiceGetRequest {
request_ref_id: Some(request_ref_id),
transaction_id: Some(transaction_id_obj),
refund_id: refund_id.to_string(),
browser_info: None,
refund_reason: None,
refund_metadata: HashMap::new(),
state: None,
}
}
// Helper function to create a register (setup mandate) request (matching your JSON format)
#[allow(clippy::field_reassign_with_default)]
fn create_register_request() -> PaymentServiceRegisterRequest {
let mut request = PaymentServiceRegisterRequest::default();
// Set amounts matching your JSON (3000 minor units)
request.minor_amount = Some(TEST_AMOUNT);
request.currency = i32::from(Currency::Usd);
// Set up card payment method with Visa network as in your JSON
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1_i32),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
// Set customer information with unique email
request.customer_name = Some(TEST_CARD_HOLDER.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": 500,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_525_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.currency = i32::from(Currency::Usd);
// Set up card payment method with Visa network as in your JSON
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1_i32),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: 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": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_525_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.currency = i32::from(Currency::Usd);
// Set up card payment method with Visa network as in your JSON
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1_i32),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
// Set customer information with unique email
request.customer_name = Some(TEST_CARD_HOLDER.to_string());
request.email = Some(generate_unique_email().into());
// Add customer acceptance as required by the server (matching your JSON: "acceptance_type": "OFFLINE")
request.customer_acceptance = Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_525_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.currency = i32::from(Currency::Usd);
// Set up card payment method with Visa network as in your JSON
let card_details = card_payment_method_type::CardType::Credit(CardDetails {
card_number: Some(CardNumber::from_str(TEST_CARD_NUMBER).unwrap()),
card_exp_month: Some(Secret::new(TEST_CARD_EXP_MONTH.to_string())),
card_exp_year: Some(Secret::new(TEST_CARD_EXP_YEAR.to_string())),
card_cvc: Some(Secret::new(TEST_CARD_CVC.to_string())),
card_holder_name: Some(Secret::new(TEST_CARD_HOLDER.to_string())),
card_issuer: None,
card_network: Some(1_i32),
card_type: None,
card_issuing_country_alpha2: None,
bank_code: None,
nick_name: None,
});
request.payment_method = Some(PaymentMethod {
payment_method: Some(payment_method::PaymentMethod::Card(CardPaymentMethodType {
card_type: Some(card_details),
})),
});
// Set customer information with unique email
request.customer_name = Some(TEST_CARD_HOLDER.to_string());
request.email = Some(generate_unique_email().into());
// Add customer acceptance as required by the server (matching your JSON: "acceptance_type": "OFFLINE")
request.customer_acceptance = Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0, // You can set this to current timestamp if needed
online_mandate_details: None,
});
// Add billing address matching your JSON format
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some("Test".to_string().into()),
last_name: Some("Customer001".to_string().into()),
line1: Some("123 Test St".to_string().into()),
line2: None,
line3: None,
city: Some("Test City".to_string().into()),
state: Some("NY".to_string().into()),
zip_code: Some("10001".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(generate_unique_email().into()),
}),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 525,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_550_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.email = Some(generate_unique_email().into());
// Add customer acceptance as required by the server (matching your JSON: "acceptance_type": "OFFLINE")
request.customer_acceptance = Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0, // You can set this to current timestamp if needed
online_mandate_details: None,
});
// Add billing address matching your JSON format
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some("Test".to_string().into()),
last_name: Some("Customer001".to_string().into()),
line1: Some("123 Test St".to_string().into()),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_550_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.email = Some(generate_unique_email().into());
// Add customer acceptance as required by the server (matching your JSON: "acceptance_type": "OFFLINE")
request.customer_acceptance = Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0, // You can set this to current timestamp if needed
online_mandate_details: None,
});
// Add billing address matching your JSON format
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some("Test".to_string().into()),
last_name: Some("Customer001".to_string().into()),
line1: Some("123 Test St".to_string().into()),
line2: None,
line3: None,
city: Some("Test City".to_string().into()),
state: Some("NY".to_string().into()),
zip_code: Some("10001".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(generate_unique_email().into()),
}),
shipping_address: None,
});
// Set auth type as NO_THREE_DS
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_550_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
request.email = Some(generate_unique_email().into());
// Add customer acceptance as required by the server (matching your JSON: "acceptance_type": "OFFLINE")
request.customer_acceptance = Some(CustomerAcceptance {
acceptance_type: i32::from(AcceptanceType::Offline),
accepted_at: 0, // You can set this to current timestamp if needed
online_mandate_details: None,
});
// Add billing address matching your JSON format
request.address = Some(PaymentAddress {
billing_address: Some(Address {
first_name: Some("Test".to_string().into()),
last_name: Some("Customer001".to_string().into()),
line1: Some("123 Test St".to_string().into()),
line2: None,
line3: None,
city: Some("Test City".to_string().into()),
state: Some("NY".to_string().into()),
zip_code: Some("10001".to_string().into()),
country_alpha2_code: Some(i32::from(CountryAlpha2::Us)),
phone_number: None,
phone_country_code: None,
email: Some(generate_unique_email().into()),
}),
shipping_address: None,
});
// Set auth type as NO_THREE_DS
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
// Set setup_future_usage to OFF_SESSION (matching your JSON: "setup_future_usage": "OFF_SESSION")
request.setup_future_usage = Some(i32::from(FutureUsage::OffSession));
// Set 3DS enrollment to false
request.enrolled_for_3ds = false;
// Set request reference ID with unique UUID (this will be unique every time)
request.request_ref_id = Some(Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("mandate"))),
});
// Set empty connector metadata
request.metadata = HashMap::new();
request
}
// Test for basic health check
#[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": 550,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_575_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
shipping_address: None,
});
// Set auth type as NO_THREE_DS
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
// Set setup_future_usage to OFF_SESSION (matching your JSON: "setup_future_usage": "OFF_SESSION")
request.setup_future_usage = Some(i32::from(FutureUsage::OffSession));
// Set 3DS enrollment to false
request.enrolled_for_3ds = false;
// Set request reference ID with unique UUID (this will be unique every time)
request.request_ref_id = Some(Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("mandate"))),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_575_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
shipping_address: None,
});
// Set auth type as NO_THREE_DS
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
// Set setup_future_usage to OFF_SESSION (matching your JSON: "setup_future_usage": "OFF_SESSION")
request.setup_future_usage = Some(i32::from(FutureUsage::OffSession));
// Set 3DS enrollment to false
request.enrolled_for_3ds = false;
// Set request reference ID with unique UUID (this will be unique every time)
request.request_ref_id = Some(Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("mandate"))),
});
// Set empty connector metadata
request.metadata = HashMap::new();
request
}
// 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(),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_575_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
shipping_address: None,
});
// Set auth type as NO_THREE_DS
request.auth_type = i32::from(AuthenticationType::NoThreeDs);
// Set setup_future_usage to OFF_SESSION (matching your JSON: "setup_future_usage": "OFF_SESSION")
request.setup_future_usage = Some(i32::from(FutureUsage::OffSession));
// Set 3DS enrollment to false
request.enrolled_for_3ds = false;
// Set request reference ID with unique UUID (this will be unique every time)
request.request_ref_id = Some(Identifier {
id_type: Some(IdType::Id(generate_unique_request_ref_id("mandate"))),
});
// Set empty connector metadata
request.metadata = HashMap::new();
request
}
// 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(common_enums::CaptureMethod::Automatic);
// println!("Auth request for auto 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": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 575,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_600_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
async fn test_health() {
grpc_test!(client, HealthClient<Channel>, {
let response = client
.check(Request::new(HealthCheckRequest {
service: "connector_service".to_string(),
}))
.await
.expect("Failed to call health check")
.into_inner();
assert_eq!(
response.status(),
grpc_api_types::health_check::health_check_response::ServingStatus::Serving
);
});
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_600_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
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(common_enums::CaptureMethod::Automatic);
// println!("Auth request for auto capture: {:?}", request);
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the 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": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_600_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
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(common_enums::CaptureMethod::Automatic);
// println!("Auth request for auto capture: {:?}", request);
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// println!("Payment authorize response for auto: {:?}", response);
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&response.status) {
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
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": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 600,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_625_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// println!("Payment authorize response for auto: {:?}", response);
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_625_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// println!("Payment authorize response for auto: {:?}", response);
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&response.status) {
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
response.status
);
}
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status - allow CHARGED, PENDING, or FAILURE (common in sandbox)
let acceptable_statuses = [
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_625_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.authorize(grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// println!("Payment authorize response for auto: {:?}", response);
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&response.status) {
assert!(
response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
response.status
);
}
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status - allow CHARGED, PENDING, or FAILURE (common in sandbox)
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
response.status
);
});
}
// 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(common_enums::CaptureMethod::Manual);
// println!("Auth request for manual capture: {:?}", auth_request);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 625,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_650_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status - allow CHARGED, PENDING, or FAILURE (common in sandbox)
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
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": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_650_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status - allow CHARGED, PENDING, or FAILURE (common in sandbox)
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
response.status
);
});
}
// 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(common_enums::CaptureMethod::Manual);
// println!("Auth request for manual capture: {:?}", auth_request);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_650_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&response);
// Verify payment status - allow CHARGED, PENDING, or FAILURE (common in sandbox)
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
response.status
);
});
}
// 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(common_enums::CaptureMethod::Manual);
// println!("Auth request for manual capture: {:?}", auth_request);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_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();
// Transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
];
// println!(
// "Payment authorize response: {:?}",
// auth_response
// );
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_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": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 650,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_675_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
add_authorizenet_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();
// Transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
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": 675,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_675_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
add_authorizenet_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();
// Transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
];
// println!(
// "Payment authorize response: {:?}",
// auth_response
// );
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 675,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_675_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
add_authorizenet_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();
// Transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
];
// println!(
// "Payment authorize response: {:?}",
// auth_response
// );
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture) - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
// println!("print acceptable statuses: {:?}", acceptable_statuses);
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// 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_authorizenet_metadata(&mut capture_grpc_request);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 675,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_700_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture) - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
// println!("print acceptable statuses: {:?}", acceptable_statuses);
assert!(
acceptable_statuses.contains(&auth_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": 700,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_700_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture) - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
// println!("print acceptable statuses: {:?}", acceptable_statuses);
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// 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_authorizenet_metadata(&mut capture_grpc_request);
// Send the capture request
let capture_response = client
.capture(capture_grpc_request)
.await
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 700,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_700_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
}
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized (for manual capture) - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
// println!("print acceptable statuses: {:?}", acceptable_statuses);
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// 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_authorizenet_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 - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&capture_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state after capture (sandbox) but was: {}",
capture_response.status
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 700,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_725_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// 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 - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
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": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 725,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_725_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// 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 - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&capture_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state after capture (sandbox) but was: {}",
capture_response.status
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
| {
"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": 725,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_725_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// 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 - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&capture_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state after capture (sandbox) but was: {}",
capture_response.status
);
});
}
// Test payment sync
#[tokio::test]
async fn test_payment_sync() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 725,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_750_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 750,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_750_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_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": 750,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_750_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to sync
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let _transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// Create get request
let get_request = create_payment_get_request(&_transaction_id);
// Add metadata headers for get request
let mut get_grpc_request = Request::new(get_request);
add_authorizenet_metadata(&mut get_grpc_request);
// Send the get request
let get_response = client
.get(get_grpc_request)
.await
.expect("gRPC payment_get call failed")
.into_inner();
// Verify the sync response
// Verify the payment status matches what we expect - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
| {
"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": 750,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_775_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// Create get request
let get_request = create_payment_get_request(&_transaction_id);
// Add metadata headers for get request
let mut get_grpc_request = Request::new(get_request);
add_authorizenet_metadata(&mut get_grpc_request);
// Send the get request
let get_response = client
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 775,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_775_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// Create get request
let get_request = create_payment_get_request(&_transaction_id);
// Add metadata headers for get request
let mut get_grpc_request = Request::new(get_request);
add_authorizenet_metadata(&mut get_grpc_request);
// Send the get request
let get_response = client
.get(get_grpc_request)
.await
.expect("gRPC payment_get call failed")
.into_inner();
// Verify the sync response
// Verify the payment status matches what we expect - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
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": 775,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_775_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// Create get request
let get_request = create_payment_get_request(&_transaction_id);
// Add metadata headers for get request
let mut get_grpc_request = Request::new(get_request);
add_authorizenet_metadata(&mut get_grpc_request);
// Send the get request
let get_response = client
.get(get_grpc_request)
.await
.expect("gRPC payment_get call failed")
.into_inner();
// Verify the sync response
// Verify the payment status matches what we expect - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&get_response.status),
"Payment get should return AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
get_response.status
);
// Verify we have transaction ID in the response
assert!(
get_response.transaction_id.is_some(),
"Transaction ID should be present in get response"
);
});
}
// Test void flow (unique to AuthorizeDotNet)
#[tokio::test]
async fn test_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to void
let auth_request = create_payment_authorize_request(common_enums::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": 775,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_800_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&get_response.status),
"Payment get should return AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
get_response.status
);
// Verify we have transaction ID in the response
assert!(
get_response.transaction_id.is_some(),
"Transaction ID should be present in get response"
);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 800,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_800_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&get_response.status),
"Payment get should return AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
get_response.status
);
// Verify we have transaction ID in the response
assert!(
get_response.transaction_id.is_some(),
"Transaction ID should be present in get response"
);
});
}
// Test void flow (unique to AuthorizeDotNet)
#[tokio::test]
async fn test_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to void
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 800,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_800_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Charged),
// i32::from(PaymentStatus::Failure),
];
assert!(
acceptable_statuses.contains(&get_response.status),
"Payment get should return AUTHORIZED, PENDING, or FAILURE state (sandbox) but was: {}",
get_response.status
);
// Verify we have transaction ID in the response
assert!(
get_response.transaction_id.is_some(),
"Transaction ID should be present in get response"
);
});
}
// Test void flow (unique to AuthorizeDotNet)
#[tokio::test]
async fn test_void() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment to void
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Manual);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Voided),
// i32::from(PaymentStatus::Failure),
];
// println!(
// "Auth response: {:?}",
// auth_response
// );
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 800,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_825_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized or handle other states - allow PENDING or FAILURE in sandbox
| {
"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": 825,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_825_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Voided),
// i32::from(PaymentStatus::Failure),
];
// println!(
// "Auth response: {:?}",
// auth_response
// );
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE (sandbox) but was: {}",
auth_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": 825,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_825_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status is authorized or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Authorized),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Voided),
// i32::from(PaymentStatus::Failure),
];
// println!(
// "Auth response: {:?}",
// auth_response
// );
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE (sandbox) but was: {}",
auth_response.status
);
// Skip void test if payment is not in AUTHORIZED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Authorized)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Allow some time for the authorization to be processed
allow_processing_time();
// Additional async delay when running with other tests to avoid conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// println!("transaction_id: {}", transaction_id);
// Create void request
let void_request = create_void_request(&transaction_id);
// println!("Void request: {:?}", void_request);
// Add metadata headers for void 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": 825,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_850_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE (sandbox) but was: {}",
auth_response.status
);
// Skip void test if payment is not in AUTHORIZED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Authorized)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Allow some time for the authorization to be processed
allow_processing_time();
| {
"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": 850,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_850_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE (sandbox) but was: {}",
auth_response.status
);
// Skip void test if payment is not in AUTHORIZED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Authorized)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Allow some time for the authorization to be processed
allow_processing_time();
// Additional async delay when running with other tests to avoid conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// println!("transaction_id: {}", transaction_id);
// Create void request
let void_request = create_void_request(&transaction_id);
// println!("Void request: {:?}", void_request);
// Add metadata headers for void request
let mut void_grpc_request = Request::new(void_request);
add_authorizenet_metadata(&mut void_grpc_request);
// println!("Void grpc request: {:?}", void_grpc_request);
// Send the void request
let void_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": 850,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_850_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in AUTHORIZED, PENDING, or FAILURE (sandbox) but was: {}",
auth_response.status
);
// Skip void test if payment is not in AUTHORIZED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Authorized)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Allow some time for the authorization to be processed
allow_processing_time();
// Additional async delay when running with other tests to avoid conflicts
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
// println!("transaction_id: {}", transaction_id);
// Create void request
let void_request = create_void_request(&transaction_id);
// println!("Void request: {:?}", void_request);
// Add metadata headers for void request
let mut void_grpc_request = Request::new(void_request);
add_authorizenet_metadata(&mut void_grpc_request);
// println!("Void grpc request: {:?}", void_grpc_request);
// Send the void request
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void_payment call failed")
.into_inner();
// Accept VOIDED status
let acceptable_statuses = [i32::from(PaymentStatus::Voided)];
// println!("Void response: {:?}", void_response);
assert!(
acceptable_statuses.contains(&void_response.status),
"Payment should be in VOIDED state but was: {}",
void_response.status
);
});
}
// Test refund flow
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
| {
"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": 850,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_875_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut void_grpc_request = Request::new(void_request);
add_authorizenet_metadata(&mut void_grpc_request);
// println!("Void grpc request: {:?}", void_grpc_request);
// Send the void request
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void_payment call failed")
.into_inner();
// Accept VOIDED status
let acceptable_statuses = [i32::from(PaymentStatus::Voided)];
// println!("Void response: {:?}", void_response);
assert!(
acceptable_statuses.contains(&void_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": 875,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_875_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut void_grpc_request = Request::new(void_request);
add_authorizenet_metadata(&mut void_grpc_request);
// println!("Void grpc request: {:?}", void_grpc_request);
// Send the void request
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void_payment call failed")
.into_inner();
// Accept VOIDED status
let acceptable_statuses = [i32::from(PaymentStatus::Voided)];
// println!("Void response: {:?}", void_response);
assert!(
acceptable_statuses.contains(&void_response.status),
"Payment should be in VOIDED state but was: {}",
void_response.status
);
});
}
// Test refund flow
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 875,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_875_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
let mut void_grpc_request = Request::new(void_request);
add_authorizenet_metadata(&mut void_grpc_request);
// println!("Void grpc request: {:?}", void_grpc_request);
// Send the void request
let void_response = client
.void(void_grpc_request)
.await
.expect("gRPC void_payment call failed")
.into_inner();
// Accept VOIDED status
let acceptable_statuses = [i32::from(PaymentStatus::Voided)];
// println!("Void response: {:?}", void_response);
assert!(
acceptable_statuses.contains(&void_response.status),
"Payment should be in VOIDED state but was: {}",
void_response.status
);
});
}
// Test refund flow
#[tokio::test]
async fn test_refund() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// First create a payment
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
| {
"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": 875,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_900_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// First create a payment
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_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
| {
"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": 900,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_900_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// First create a payment
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// Skip refund test if payment is not in CHARGED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Charged)
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 900,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_900_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// First create a payment
let auth_request = create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add metadata headers for auth request
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the auth request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC payment_authorize call failed")
.into_inner();
// Extract the transaction ID
let transaction_id = extract_transaction_id(&auth_response);
// Verify payment status or handle other states - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// Skip refund test if payment is not in CHARGED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Charged)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Wait a bit to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_authorizenet_metadata(&mut refund_grpc_request);
// Send the refund request
let refund_result = client.refund(refund_grpc_request).await;
// Check if we have a successful refund OR any expected error (including gRPC errors)
let is_success_status = refund_result.as_ref().is_ok_and(|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": 900,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_925_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
auth_response.status
);
// Skip refund test if payment is not in CHARGED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Charged)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Wait a bit to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create refund request
let refund_request = create_refund_request(&transaction_id);
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 925,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_925_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
auth_response.status
);
// Skip refund test if payment is not in CHARGED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Charged)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Wait a bit to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_authorizenet_metadata(&mut refund_grpc_request);
// Send the refund request
let refund_result = client.refund(refund_grpc_request).await;
// Check if we have a successful refund OR any expected error (including gRPC errors)
let is_success_status = refund_result.as_ref().is_ok_and(|response| {
response.get_ref().status == i32::from(RefundStatus::RefundSuccess)
});
let has_expected_error = refund_result.as_ref().is_ok_and(|response| {
let error_msg = response.get_ref().error_message();
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 925,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_925_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
auth_response.status
);
// Skip refund test if payment is not in CHARGED state (but allow test to continue if PENDING)
if auth_response.status != i32::from(PaymentStatus::Charged)
&& auth_response.status != i32::from(PaymentStatus::Pending)
{
return;
}
// Wait a bit to ensure the payment is fully processed
tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
// Create refund request
let refund_request = create_refund_request(&transaction_id);
// Add metadata headers for refund request
let mut refund_grpc_request = Request::new(refund_request);
add_authorizenet_metadata(&mut refund_grpc_request);
// Send the refund request
let refund_result = client.refund(refund_grpc_request).await;
// Check if we have a successful refund OR any expected error (including gRPC errors)
let is_success_status = refund_result.as_ref().is_ok_and(|response| {
response.get_ref().status == i32::from(RefundStatus::RefundSuccess)
});
let has_expected_error = refund_result.as_ref().is_ok_and(|response| {
let error_msg = response.get_ref().error_message();
error_msg.contains(
"The referenced transaction does not meet the criteria for issuing a credit.",
) || error_msg.contains("credit")
|| error_msg.contains("refund")
|| error_msg.contains("transaction")
|| response.get_ref().status == i32::from(RefundStatus::RefundFailure)
});
let has_grpc_error = refund_result.is_err();
assert!(
is_success_status || has_expected_error || has_grpc_error,
"Refund should either succeed, have expected error, or gRPC error (common in sandbox). Got: {refund_result:?}"
);
});
}
// Test register (setup mandate) flow
#[tokio::test]
async fn test_register() {
| {
"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": 925,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_950_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
response.get_ref().status == i32::from(RefundStatus::RefundSuccess)
});
let has_expected_error = refund_result.as_ref().is_ok_and(|response| {
let error_msg = response.get_ref().error_message();
error_msg.contains(
"The referenced transaction does not meet the criteria for issuing a credit.",
) || error_msg.contains("credit")
|| error_msg.contains("refund")
|| error_msg.contains("transaction")
|| response.get_ref().status == i32::from(RefundStatus::RefundFailure)
});
let has_grpc_error = refund_result.is_err();
| {
"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": 950,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_950_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
response.get_ref().status == i32::from(RefundStatus::RefundSuccess)
});
let has_expected_error = refund_result.as_ref().is_ok_and(|response| {
let error_msg = response.get_ref().error_message();
error_msg.contains(
"The referenced transaction does not meet the criteria for issuing a credit.",
) || error_msg.contains("credit")
|| error_msg.contains("refund")
|| error_msg.contains("transaction")
|| response.get_ref().status == i32::from(RefundStatus::RefundFailure)
});
let has_grpc_error = refund_result.is_err();
assert!(
is_success_status || has_expected_error || has_grpc_error,
"Refund should either succeed, have expected error, or gRPC error (common in sandbox). Got: {refund_result:?}"
);
});
}
// Test register (setup mandate) flow
#[tokio::test]
async fn test_register() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the register request
let request = create_register_request();
// Add metadata headers
| {
"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": 950,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_950_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
response.get_ref().status == i32::from(RefundStatus::RefundSuccess)
});
let has_expected_error = refund_result.as_ref().is_ok_and(|response| {
let error_msg = response.get_ref().error_message();
error_msg.contains(
"The referenced transaction does not meet the criteria for issuing a credit.",
) || error_msg.contains("credit")
|| error_msg.contains("refund")
|| error_msg.contains("transaction")
|| response.get_ref().status == i32::from(RefundStatus::RefundFailure)
});
let has_grpc_error = refund_result.is_err();
assert!(
is_success_status || has_expected_error || has_grpc_error,
"Refund should either succeed, have expected error, or gRPC error (common in sandbox). Got: {refund_result:?}"
);
});
}
// Test register (setup mandate) flow
#[tokio::test]
async fn test_register() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the register request
let request = create_register_request();
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify the response
assert!(
response.registration_id.is_some(),
"Registration ID should be present"
);
// Check if we have a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 50,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 950,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_975_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the register request
let request = create_register_request();
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.register(grpc_request)
.await
.expect("gRPC register 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": 975,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_975_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the register request
let request = create_register_request();
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify the response
assert!(
response.registration_id.is_some(),
"Registration ID should be present"
);
// Check if we have a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
// Verify the mandate reference has the expected structure
if let Some(mandate_ref) = &response.mandate_reference {
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": 975,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_975_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create the register request
let request = create_register_request();
// Add metadata headers
let mut grpc_request = Request::new(request);
add_authorizenet_metadata(&mut grpc_request);
// Send the request
let response = client
.register(grpc_request)
.await
.expect("gRPC register call failed")
.into_inner();
// Verify the response
assert!(
response.registration_id.is_some(),
"Registration ID should be present"
);
// Check if we have a mandate reference
assert!(
response.mandate_reference.is_some(),
"Mandate reference should be present"
);
// Verify the mandate reference has the expected structure
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some(),
"Mandate ID should be present"
);
// Verify the composite ID format (profile_id-payment_profile_id)
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(
mandate_id.contains('-') || !mandate_id.is_empty(),
"Mandate ID should be either a composite ID or a profile ID"
);
}
}
// Verify no error occurred
assert!(
response.error_message.is_none() || response.error_message.as_ref().unwrap().is_empty(),
"No error message should be present for successful register"
);
});
}
| {
"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": 975,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1000_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Verify the mandate reference has the expected structure
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some(),
"Mandate ID should be present"
);
// Verify the composite ID format (profile_id-payment_profile_id)
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(
mandate_id.contains('-') || !mandate_id.is_empty(),
"Mandate ID should be either a composite ID or a profile 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": 1000,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1000_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Verify the mandate reference has the expected structure
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some(),
"Mandate ID should be present"
);
// Verify the composite ID format (profile_id-payment_profile_id)
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(
mandate_id.contains('-') || !mandate_id.is_empty(),
"Mandate ID should be either a composite ID or a profile ID"
);
}
}
// Verify no error occurred
assert!(
response.error_message.is_none() || response.error_message.as_ref().unwrap().is_empty(),
"No error message should be present for successful register"
);
});
}
// Test authorization with setup_future_usage
#[tokio::test]
async fn test_authorize_with_setup_future_usage() {
grpc_test!(client, PaymentServiceClient<Channel>, {
| {
"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": 1000,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1000_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
);
// Verify the mandate reference has the expected structure
if let Some(mandate_ref) = &response.mandate_reference {
assert!(
mandate_ref.mandate_id.is_some(),
"Mandate ID should be present"
);
// Verify the composite ID format (profile_id-payment_profile_id)
if let Some(mandate_id) = &mandate_ref.mandate_id {
assert!(
mandate_id.contains('-') || !mandate_id.is_empty(),
"Mandate ID should be either a composite ID or a profile ID"
);
}
}
// Verify no error occurred
assert!(
response.error_message.is_none() || response.error_message.as_ref().unwrap().is_empty(),
"No error message should be present for successful register"
);
});
}
// Test authorization with setup_future_usage
#[tokio::test]
async fn test_authorize_with_setup_future_usage() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create an authorization request with setup_future_usage
let mut auth_request =
create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add setup_future_usage to trigger profile creation
auth_request.setup_future_usage = Some(i32::from(FutureUsage::OnSession));
// Add metadata headers
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the authorization request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC authorize with setup_future_usage call failed")
.into_inner();
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
| {
"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": 1000,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1025_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Test authorization with setup_future_usage
#[tokio::test]
async fn test_authorize_with_setup_future_usage() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create an authorization request with setup_future_usage
let mut auth_request =
create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add setup_future_usage to trigger profile creation
auth_request.setup_future_usage = Some(i32::from(FutureUsage::OnSession));
// Add metadata headers
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_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": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 1025,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1025_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Test authorization with setup_future_usage
#[tokio::test]
async fn test_authorize_with_setup_future_usage() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create an authorization request with setup_future_usage
let mut auth_request =
create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add setup_future_usage to trigger profile creation
auth_request.setup_future_usage = Some(i32::from(FutureUsage::OnSession));
// Add metadata headers
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the authorization request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC authorize with setup_future_usage call failed")
.into_inner();
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&auth_response.status) {
assert!(
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 30,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 1025,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1025_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
// Test authorization with setup_future_usage
#[tokio::test]
async fn test_authorize_with_setup_future_usage() {
grpc_test!(client, PaymentServiceClient<Channel>, {
// Create an authorization request with setup_future_usage
let mut auth_request =
create_payment_authorize_request(common_enums::CaptureMethod::Automatic);
// Add setup_future_usage to trigger profile creation
auth_request.setup_future_usage = Some(i32::from(FutureUsage::OnSession));
// Add metadata headers
let mut auth_grpc_request = Request::new(auth_request);
add_authorizenet_metadata(&mut auth_grpc_request);
// Send the authorization request
let auth_response = client
.authorize(auth_grpc_request)
.await
.expect("gRPC authorize with setup_future_usage call failed")
.into_inner();
// Verify the response - transaction_id may not be present for failed or pending payments
let successful_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Verify payment status - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Authorized),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// When setup_future_usage is set, a customer profile is created
// The mandate can be used in subsequent transactions
| {
"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": 1025,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1050_15 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Verify payment status - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
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": 1050,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1050_30 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Verify payment status - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Authorized),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// When setup_future_usage is set, a customer profile is created
// The mandate can be used in subsequent transactions
});
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 27,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 1050,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_7957748028931523727_1050_50 | clm | snippet | // connector-service/backend/grpc-server/tests/authorizedotnet_payment_flows_test.rs
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Authorized),
];
if successful_statuses.contains(&auth_response.status) {
assert!(
auth_response.transaction_id.is_some(),
"Transaction ID should be present for successful payments, but status was: {}",
auth_response.status
);
}
// Verify payment status - allow PENDING or FAILURE in sandbox
let acceptable_statuses = [
i32::from(PaymentStatus::Charged),
i32::from(PaymentStatus::Pending),
i32::from(PaymentStatus::Authorized),
];
assert!(
acceptable_statuses.contains(&auth_response.status),
"Payment should be in CHARGED, PENDING, or FAILURE state (sandbox) but was: {}",
auth_response.status
);
// When setup_future_usage is set, a customer profile is created
// The mandate can be used in subsequent transactions
});
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 27,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 1050,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_1061119781833247450_0_15 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic, clippy::print_stdout)]
mod tests {
use common_enums::{Currency, CurrencyError};
#[test]
fn test_zero_decimal_currencies() {
// Test currencies that should have 0 decimal places
assert_eq!(
Currency::JPY
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
| {
"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_1061119781833247450_0_30 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic, clippy::print_stdout)]
mod tests {
use common_enums::{Currency, CurrencyError};
#[test]
fn test_zero_decimal_currencies() {
// Test currencies that should have 0 decimal places
assert_eq!(
Currency::JPY
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::KRW
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::VND
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::BIF
.number_of_digits_after_decimal_point()
.unwrap(),
| {
"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_1061119781833247450_0_50 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic, clippy::print_stdout)]
mod tests {
use common_enums::{Currency, CurrencyError};
#[test]
fn test_zero_decimal_currencies() {
// Test currencies that should have 0 decimal places
assert_eq!(
Currency::JPY
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::KRW
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::VND
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::BIF
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::CLP
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
}
#[test]
fn test_two_decimal_currencies() {
// Test currencies that should have 2 decimal places
assert_eq!(
Currency::USD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
| {
"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_1061119781833247450_25_15 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
);
assert_eq!(
Currency::BIF
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::CLP
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": 15,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": 25,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_snippet_1061119781833247450_25_30 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
);
assert_eq!(
Currency::BIF
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::CLP
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
}
#[test]
fn test_two_decimal_currencies() {
// Test currencies that should have 2 decimal places
assert_eq!(
Currency::USD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::EUR
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
| {
"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_1061119781833247450_25_50 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
);
assert_eq!(
Currency::BIF
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
assert_eq!(
Currency::CLP
.number_of_digits_after_decimal_point()
.unwrap(),
0
);
}
#[test]
fn test_two_decimal_currencies() {
// Test currencies that should have 2 decimal places
assert_eq!(
Currency::USD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::EUR
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::GBP
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::CAD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::AUD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
}
| {
"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_1061119781833247450_50_15 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
Currency::EUR
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::GBP
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::CAD
.number_of_digits_after_decimal_point()
.unwrap(),
| {
"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_1061119781833247450_50_30 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
Currency::EUR
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::GBP
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::CAD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::AUD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
}
#[test]
fn test_three_decimal_currencies() {
// Test currencies that should have 3 decimal places
assert_eq!(
Currency::BHD
| {
"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_1061119781833247450_50_50 | clm | snippet | // connector-service/backend/grpc-server/tests/test_currency.rs
Currency::EUR
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::GBP
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::CAD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
assert_eq!(
Currency::AUD
.number_of_digits_after_decimal_point()
.unwrap(),
2
);
}
#[test]
fn test_three_decimal_currencies() {
// Test currencies that should have 3 decimal places
assert_eq!(
Currency::BHD
.number_of_digits_after_decimal_point()
.unwrap(),
3
);
assert_eq!(
Currency::JOD
.number_of_digits_after_decimal_point()
.unwrap(),
3
);
assert_eq!(
Currency::KWD
.number_of_digits_after_decimal_point()
.unwrap(),
3
);
assert_eq!(
Currency::OMR
.number_of_digits_after_decimal_point()
.unwrap(),
| {
"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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.