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::region::{
BuiltInRegionGroupResponse, RegionCountriesResponse, RegionResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Regions {
inner: Arc<Inner>,
}
impl Regions {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn create(
&self,
profile_id: &str,
params: &RegionCreateRequest,
) -> Result<RegionResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/regions",
Some(&body),
&profile_query(profile_id),
None,
)
.await
}
pub async fn list(&self, profile_id: &str) -> Result<Vec<RegionResponse>> {
self.inner
.request(
HttpMethod::Get,
"/regions/list",
None,
&profile_query(profile_id),
None,
)
.await
}
pub async fn groups(&self) -> Result<Vec<BuiltInRegionGroupResponse>> {
self.inner
.request(HttpMethod::Get, "/regions/groups", None, &[], None)
.await
}
pub async fn retrieve(&self, region_id: &str, profile_id: &str) -> Result<RegionResponse> {
let path = region_path(region_id);
self.inner
.request(
HttpMethod::Get,
&path,
None,
&profile_query(profile_id),
None,
)
.await
}
pub async fn update(
&self,
region_id: &str,
profile_id: &str,
params: &RegionUpdateRequest,
) -> Result<RegionResponse> {
params.validate()?;
let path = region_path(region_id);
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Put,
&path,
Some(&body),
&profile_query(profile_id),
None,
)
.await
}
pub async fn delete(&self, region_id: &str, profile_id: &str) -> Result<bool> {
let path = region_path(region_id);
self.inner
.request(
HttpMethod::Delete,
&path,
None,
&profile_query(profile_id),
None,
)
.await
}
pub async fn countries(
&self,
region_id: &str,
profile_id: &str,
) -> Result<RegionCountriesResponse> {
let path = format!("{}/countries", region_path(region_id));
self.inner
.request(
HttpMethod::Get,
&path,
None,
&profile_query(profile_id),
None,
)
.await
}
pub async fn set_countries(
&self,
region_id: &str,
profile_id: &str,
params: &RegionSetCountriesRequest,
) -> Result<RegionCountriesResponse> {
let path = format!("{}/countries", region_path(region_id));
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Put,
&path,
Some(&body),
&profile_query(profile_id),
None,
)
.await
}
}
fn region_path(region_id: &str) -> String {
format!("/regions/{}", encode_segment(region_id))
}
fn profile_query(profile_id: &str) -> Vec<(&'static str, String)> {
vec![("profile_id", profile_id.to_string())]
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct RegionCreateRequest {
pub region_name: String,
pub region_code: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl RegionCreateRequest {
pub fn new(region_name: impl Into<String>, region_code: impl Into<String>) -> Self {
Self {
region_name: region_name.into(),
region_code: region_code.into(),
..Default::default()
}
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
const REGION_CREATE_REQUEST_NAMED: &[&str] = &["region_name", "region_code", "description"];
impl ValidateRequest for RegionCreateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if REGION_CREATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on RegionCreateRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct RegionUpdateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub region_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl RegionUpdateRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn region_name(mut self, region_name: impl Into<String>) -> Self {
self.region_name = Some(region_name.into());
self
}
#[must_use]
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
#[must_use]
pub fn is_active(mut self, is_active: bool) -> Self {
self.is_active = Some(is_active);
self
}
}
const REGION_UPDATE_REQUEST_NAMED: &[&str] = &["region_name", "description", "is_active"];
impl ValidateRequest for RegionUpdateRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if REGION_UPDATE_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on RegionUpdateRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct RegionSetCountriesRequest {
pub countries: Vec<String>,
}
impl RegionSetCountriesRequest {
pub fn new(countries: Vec<String>) -> Self {
Self { countries }
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const REGION_JSON: &str = r#"{
"id": "reg_1",
"profile_id": "pro_1",
"region_name": "Nordics",
"region_code": "NORDICS",
"is_active": true,
"created_at": "2024-01-01T00:00:00Z",
"modified_at": "2024-01-02T00:00:00Z",
"description": "SE/NO/DK",
"surprise_field": 1
}"#;
const COUNTRIES_JSON: &str = r#"{"region_id":"reg_1","countries":["SE","NO"]}"#;
#[tokio::test]
async fn create_posts_to_regions_with_the_profile_scope() {
let (client, mock) = client_with(vec![Step::ok(REGION_JSON)]);
let params = RegionCreateRequest::new("Nordics", "NORDICS");
let region = client.regions().create("pro_1", ¶ms).await.unwrap();
assert_eq!(region.id, "reg_1");
assert_eq!(region.region_code, "NORDICS");
assert_eq!(region.description.as_deref(), Some("SE/NO/DK"));
assert!(region.is_active);
assert_eq!(region.extra["surprise_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/regions?profile_id=pro_1");
let body = seen[0].body_json();
assert_eq!(body["region_name"], "Nordics");
assert_eq!(body["region_code"], "NORDICS");
}
#[tokio::test]
async fn list_gets_the_list_path_with_the_profile_scope() {
let (client, mock) = client_with(vec![Step::ok(&format!("[{REGION_JSON}]"))]);
let regions = client.regions().list("pro_1").await.unwrap();
assert_eq!(regions[0].profile_id, "pro_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/regions/list?profile_id=pro_1"
);
}
#[tokio::test]
async fn groups_gets_the_groups_path_unscoped() {
let (client, mock) = client_with(vec![Step::ok(
r#"[{"code":"EU","name":"European Union","countries":["DE","FR"]}]"#,
)]);
let groups = client.regions().groups().await.unwrap();
assert_eq!(groups[0].code, "EU");
assert_eq!(groups[0].name, "European Union");
assert_eq!(groups[0].countries, ["DE", "FR"]);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/regions/groups");
}
#[tokio::test]
async fn retrieve_encodes_the_region_id() {
let (client, mock) = client_with(vec![Step::ok(REGION_JSON)]);
client.regions().retrieve("reg/1", "pro_1").await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/regions/reg%2F1?profile_id=pro_1"
);
}
#[tokio::test]
async fn update_puts_the_region_path_with_a_body() {
let (client, mock) = client_with(vec![Step::ok(REGION_JSON)]);
let params = RegionUpdateRequest::new()
.region_name("Nordics EU")
.is_active(false);
client
.regions()
.update("reg_1", "pro_1", ¶ms)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/regions/reg_1?profile_id=pro_1"
);
let body = seen[0].body_json();
assert_eq!(body["region_name"], "Nordics EU");
assert_eq!(body["is_active"], false);
}
#[tokio::test]
async fn delete_deletes_the_region_and_decodes_the_bare_boolean() {
let (client, mock) = client_with(vec![Step::ok("true")]);
let out = client.regions().delete("reg_1", "pro_1").await.unwrap();
assert!(out);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/regions/reg_1?profile_id=pro_1"
);
}
#[tokio::test]
async fn countries_gets_the_countries_sub_path() {
let (client, mock) = client_with(vec![Step::ok(COUNTRIES_JSON)]);
let out = client.regions().countries("reg_1", "pro_1").await.unwrap();
assert_eq!(out.region_id, "reg_1");
assert_eq!(out.countries, ["SE", "NO"]);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/regions/reg_1/countries?profile_id=pro_1"
);
}
#[tokio::test]
async fn set_countries_puts_the_full_membership() {
let (client, mock) = client_with(vec![Step::ok(COUNTRIES_JSON)]);
let params = RegionSetCountriesRequest::new(vec!["SE".to_string(), "NO".to_string()]);
let out = client
.regions()
.set_countries("reg_1", "pro_1", ¶ms)
.await
.unwrap();
assert_eq!(out.countries, ["SE", "NO"]);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/regions/reg_1/countries?profile_id=pro_1"
);
assert_eq!(seen[0].body_json()["countries"], json!(["SE", "NO"]));
}
#[test]
fn region_create_request_named_fields_are_complete() {
let req = RegionCreateRequest::new("Nordics", "NORDICS").description("SE/NO/DK");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
REGION_CREATE_REQUEST_NAMED.contains(&key.as_str()),
"REGION_CREATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn region_update_request_named_fields_are_complete() {
let req = RegionUpdateRequest::new()
.region_name("Nordics")
.description("SE/NO/DK")
.is_active(true);
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
REGION_UPDATE_REQUEST_NAMED.contains(&key.as_str()),
"REGION_UPDATE_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn create_validate_rejects_colliding_extra_key() {
let mut req = RegionCreateRequest::new("Nordics", "NORDICS");
req.extra.insert("region_code".to_string(), json!("OTHER"));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("region_code")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
#[test]
fn update_validate_rejects_colliding_extra_key() {
let mut req = RegionUpdateRequest::new();
req.extra.insert("region_name".to_string(), json!("other"));
match req.validate().unwrap_err() {
DelopayError::InvalidRequest(msg) => assert!(msg.contains("region_name")),
other => panic!("expected InvalidRequest, got {other:?}"),
}
}
}