use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::processor_import::{
PspImportIssuesResponse, PspImportLatestResponse, PspImportRunResponse,
PspImportSourcesResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct ProcessorImports {
inner: Arc<Inner>,
}
impl ProcessorImports {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn sources(&self, test_mode: bool) -> Result<PspImportSourcesResponse> {
self.inner
.request(
HttpMethod::Get,
"/refunds-disputes/imports/sources",
None,
&[("test_mode", test_mode.to_string())],
None,
)
.await
}
pub async fn create(&self, params: &PspImportCreateRequest) -> Result<PspImportRunResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request_body_keyed(
HttpMethod::Post,
"/refunds-disputes/imports",
Some(&body),
None,
)
.await
}
pub async fn latest(&self, test_mode: bool) -> Result<PspImportLatestResponse> {
self.inner
.request(
HttpMethod::Get,
"/refunds-disputes/imports/latest",
None,
&[("test_mode", test_mode.to_string())],
None,
)
.await
}
pub async fn retrieve(&self, import_id: &str) -> Result<PspImportRunResponse> {
self.inner
.request(HttpMethod::Get, &import_path(import_id), None, &[], None)
.await
}
pub async fn issues(
&self,
import_id: &str,
limit: Option<u32>,
offset: Option<u32>,
) -> Result<PspImportIssuesResponse> {
let path = format!("{}/issues", import_path(import_id));
let mut query = Vec::new();
if let Some(v) = limit {
query.push(("limit", v.to_string()));
}
if let Some(v) = offset {
query.push(("offset", v.to_string()));
}
self.inner
.request(HttpMethod::Get, &path, None, &query, None)
.await
}
pub async fn cancel(&self, import_id: &str) -> Result<PspImportRunResponse> {
let path = format!("{}/cancel", import_path(import_id));
self.inner
.request_body_keyed(HttpMethod::Post, &path, None, None)
.await
}
}
fn import_path(import_id: &str) -> String {
format!("/refunds-disputes/imports/{}", encode_segment(import_id))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum PspImportRecordType {
Refund,
Dispute,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PspImportCreateRequest {
pub test_mode: bool,
pub start_time: String,
pub record_types: Vec<PspImportRecordType>,
pub merchant_connector_ids: Vec<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl PspImportCreateRequest {
pub fn new(
test_mode: bool,
start_time: impl Into<String>,
record_types: Vec<PspImportRecordType>,
merchant_connector_ids: Vec<String>,
) -> Self {
Self {
test_mode,
start_time: start_time.into(),
record_types,
merchant_connector_ids,
extra: serde_json::Map::new(),
}
}
}
const PSP_IMPORT_CREATE_REQUEST_NAMED: &[&str] = &[
"test_mode",
"start_time",
"record_types",
"merchant_connector_ids",
];
impl ValidateRequest for PspImportCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if PSP_IMPORT_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on PspImportCreateRequest"
)));
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with, client_with_retries};
use serde_json::json;
const RUN_JSON: &str = r#"{
"id": "imp_1", "test_mode": true, "start_time": "2026-01-01T00:00:00Z",
"end_time": "2026-02-01T00:00:00Z", "record_types": ["refund", "dispute"],
"status": "running", "cancel_requested": false,
"created_at": "2026-02-01T00:00:00Z",
"totals": {"fetched": 10, "imported": 7, "already_present": 2, "skipped": 1, "failed": 0},
"sources": [{
"merchant_connector_id": "mca_1", "connector": "stripe", "record_type": "refund",
"status": "running",
"counts": {"fetched": 10, "imported": 7, "already_present": 2, "skipped": 1, "failed": 0},
"progress_done": 10, "progress_total": 40, "updated_at": "2026-02-01T00:01:00Z"
}],
"run_surprise": 1
}"#;
#[tokio::test]
async fn sources_sends_the_environment() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"accounts":[{"merchant_connector_id":"mca_1","connector":"stripe",
"profile_id":"pro_1","records":[{"record_type":"dispute",
"availability":"per_payment","reason":null}],"x":1}]}"#,
)]);
let out = client.processor_imports().sources(true).await.unwrap();
assert_eq!(out.accounts[0].records[0].availability, "per_payment");
assert_eq!(out.accounts[0].extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/refunds-disputes/imports/sources?test_mode=true"
);
}
#[tokio::test]
async fn create_posts_the_import() {
let (client, mock) = client_with(vec![Step::ok(RUN_JSON)]);
let req = PspImportCreateRequest::new(
true,
"2026-01-01T00:00:00Z",
vec![PspImportRecordType::Refund, PspImportRecordType::Dispute],
vec!["mca_1".to_string()],
);
let run = client.processor_imports().create(&req).await.unwrap();
assert_eq!(run.totals.imported, 7);
assert_eq!(run.sources[0].progress_total, Some(40));
assert_eq!(run.extra["run_surprise"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/refunds-disputes/imports");
assert_eq!(
seen[0].body_json(),
json!({
"test_mode": true,
"start_time": "2026-01-01T00:00:00Z",
"record_types": ["refund", "dispute"],
"merchant_connector_ids": ["mca_1"]
})
);
}
#[tokio::test]
async fn create_is_not_retried_on_5xx() {
let (client, mock) = client_with_retries(
vec![Step::status(500, r#"{"error":{"message":"boom"}}"#)],
2,
);
let req = PspImportCreateRequest::new(true, "2026-01-01T00:00:00Z", vec![], vec![]);
client.processor_imports().create(&req).await.unwrap_err();
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn latest_sends_the_environment_and_decodes_no_run() {
let (client, mock) = client_with(vec![Step::ok(r#"{"run":null,"x":1}"#)]);
let out = client.processor_imports().latest(false).await.unwrap();
assert!(out.run.is_none());
assert_eq!(out.extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/refunds-disputes/imports/latest?test_mode=false"
);
}
#[tokio::test]
async fn retrieve_encodes_the_import_id() {
let (client, mock) = client_with(vec![Step::ok(RUN_JSON)]);
let run = client.processor_imports().retrieve("imp/1").await.unwrap();
assert_eq!(run.status, "running");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/refunds-disputes/imports/imp%2F1"
);
}
#[tokio::test]
async fn issues_sends_the_page() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"issues":[{"merchant_connector_id":"mca_1","record_type":"dispute",
"connector_record_id":"du_1","outcome":"skipped","reason":"payment_not_found",
"created_at":"2026-02-01T00:00:00Z","x":1}],"has_more":true}"#,
)]);
let out = client
.processor_imports()
.issues("imp_1", Some(50), Some(100))
.await
.unwrap();
assert!(out.has_more);
assert_eq!(out.issues[0].reason, "payment_not_found");
assert_eq!(out.issues[0].extra["x"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/refunds-disputes/imports/imp_1/issues?limit=50&offset=100"
);
}
#[tokio::test]
async fn cancel_posts_without_a_body() {
let (client, mock) = client_with(vec![Step::ok(RUN_JSON)]);
client.processor_imports().cancel("imp_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/refunds-disputes/imports/imp_1/cancel"
);
assert!(seen[0].body.is_none());
}
#[test]
fn psp_import_create_request_named_fields_are_complete() {
let req = PspImportCreateRequest::new(
false,
"2026-01-01T00:00:00Z",
vec![PspImportRecordType::Refund],
vec!["mca_1".to_string()],
);
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
PSP_IMPORT_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"PSP_IMPORT_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = PspImportCreateRequest::new(false, "t", vec![], vec![]);
req.extra.insert("test_mode".to_string(), json!(true));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("test_mode")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[tokio::test]
async fn writes_ignore_the_client_wide_idempotency_key() {
let steps = (0..2)
.map(|_| Step::status(503, r#"{"error":{"message":"down"}}"#))
.collect();
let (client, mock) = crate::http::mock::client_with_retries(steps, 2);
let client = client.with_idempotency_key("client-key");
client
.processor_imports()
.create(&PspImportCreateRequest::new(
true,
"2026-01-01T00:00:00Z",
vec![PspImportRecordType::Refund],
vec!["mca_1".to_string()],
))
.await
.unwrap_err();
client
.processor_imports()
.cancel("imp_1")
.await
.unwrap_err();
assert_eq!(mock.call_count(), 2);
for seen in mock.seen.lock().unwrap().iter() {
assert!(
!seen.had_idempotency_key(),
"{} sent the client key",
seen.url
);
}
}
#[tokio::test]
async fn writes_are_not_retried_after_a_network_error_with_a_client_key() {
let steps = (0..2)
.map(|_| Step::Fail(crate::http::transport::TransportErrorKind::Connect))
.collect();
let (client, mock) = crate::http::mock::client_with_retries(steps, 2);
let client = client.with_idempotency_key("client-key");
client
.processor_imports()
.create(&PspImportCreateRequest::new(
true,
"2026-01-01T00:00:00Z",
vec![PspImportRecordType::Dispute],
vec!["mca_1".to_string()],
))
.await
.unwrap_err();
client
.processor_imports()
.cancel("imp_1")
.await
.unwrap_err();
assert_eq!(mock.call_count(), 2);
let seen = mock.seen.lock().unwrap();
for request in seen.iter() {
assert!(
!request.had_idempotency_key(),
"{} sent the client key",
request.url
);
}
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/refunds-disputes/imports")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
(
"POST",
"https://api.test/refunds-disputes/imports/imp_1/cancel"
)
);
}
}