API失敗時のテストコードをrelease/v0.1.0-beta.3にマージ

README.md

@@ -18,12 +18,12 @@ cargo add japanese-address-parser
 ### Async Api
 
 ```rust
-use japanese_address_parser::api::client::ApiImpl;
+use japanese_address_parser::api::{Api, ApiImpl};
 use japanese_address_parser::parser::parse;
 
 #[tokio::main]
 async fn main() {
-    let async_api = ApiImpl {};
+    let async_api = ApiImpl::new();
     let parse_result = parse(async_api, "東京都千代田区丸の内1-1-1").await;
     println!("{:?}", parse_result);
 }
@@ -32,11 +32,11 @@ async fn main() {
 ### Blocking Api
 
 ```rust
-use japanese_address_parser::api::blocking::Client;
+use japanese_address_parser::api::{BlockingApi, BlockingApiImpl};
 use japanese_address_parser::parser::parse_blocking;
 
 fn main() {
-    let blocking_api = Client {};
+    let blocking_api = BlockingApiImpl::new();
     let parse_result = parse_blocking(blocking_api, "東京都千代田区丸の内1-1-1");
     println!("{:?}", parse_result);
 }

src/api.rs

@@ -1,12 +1,14 @@
-#[cfg(not(target_arch = "wasm32"))]
-pub mod blocking;
-pub mod client;
+pub mod city_master_api;
+pub mod prefecture_master_api;
 
+use crate::api::city_master_api::CityMasterApi;
+use crate::api::prefecture_master_api::PrefectureMasterApi;
 use crate::entity::{City, Prefecture};
 use crate::err::Error;
 use std::future::Future;
 
 pub trait Api {
+    fn new() -> Self;
     fn get_prefecture_master(
         &self,
         prefecture_name: &str,
@@ -18,7 +20,73 @@ pub trait Api {
     ) -> impl Future<Output = Result<City, Error>>;
 }
 
+pub struct ApiImpl {
+    pub prefecture_master_api: PrefectureMasterApi,
+    pub city_master_api: CityMasterApi,
+}
+
+impl Api for ApiImpl {
+    fn new() -> Self {
+        ApiImpl {
+            prefecture_master_api: PrefectureMasterApi {
+                server_url:
+                    "https://yuukitoriyama.github.io/geolonia-japanese-addresses-accompanist",
+            },
+            city_master_api: CityMasterApi {
+                server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+            },
+        }
+    }
+
+    fn get_prefecture_master(
+        &self,
+        prefecture_name: &str,
+    ) -> impl Future<Output = Result<Prefecture, Error>> {
+        self.prefecture_master_api.get(prefecture_name)
+    }
+
+    fn get_city_master(
+        &self,
+        prefecture_name: &str,
+        city_name: &str,
+    ) -> impl Future<Output = Result<City, Error>> {
+        self.city_master_api.get(prefecture_name, city_name)
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
 pub trait BlockingApi {
+    fn new() -> Self;
     fn get_prefecture_master(&self, prefecture_name: &str) -> Result<Prefecture, Error>;
     fn get_city_master(&self, prefecture_name: &str, city_name: &str) -> Result<City, Error>;
 }
+
+#[cfg(not(target_arch = "wasm32"))]
+pub struct BlockingApiImpl {
+    prefecture_master_api: PrefectureMasterApi,
+    city_master_api: CityMasterApi,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl BlockingApi for BlockingApiImpl {
+    fn new() -> Self {
+        BlockingApiImpl {
+            prefecture_master_api: PrefectureMasterApi {
+                server_url:
+                    "https://yuukitoriyama.github.io/geolonia-japanese-addresses-accompanist",
+            },
+            city_master_api: CityMasterApi {
+                server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+            },
+        }
+    }
+
+    fn get_prefecture_master(&self, prefecture_name: &str) -> Result<Prefecture, Error> {
+        self.prefecture_master_api.get_blocking(prefecture_name)
+    }
+
+    fn get_city_master(&self, prefecture_name: &str, city_name: &str) -> Result<City, Error> {
+        self.city_master_api
+            .get_blocking(prefecture_name, city_name)
+    }
+}

src/api/city_master_api.rs

@@ -0,0 +1,120 @@
+use crate::entity::{City, Town};
+use crate::err::{ApiErrorKind, Error};
+
+pub struct CityMasterApi {
+    pub server_url: &'static str,
+}
+
+impl CityMasterApi {
+    pub async fn get(&self, prefecture_name: &str, city_name: &str) -> Result<City, Error> {
+        let endpoint = format!("{}/{}/{}.json", self.server_url, prefecture_name, city_name);
+        let response = match reqwest::get(&endpoint).await {
+            Ok(result) => result,
+            Err(_) => return Err(Error::new_api_error(ApiErrorKind::Deserialize(endpoint))),
+        };
+        if response.status() == 200 {
+            match response.json::<Vec<Town>>().await {
+                Ok(result) => Ok(City {
+                    name: city_name.to_string(),
+                    towns: result,
+                }),
+                Err(_) => Err(Error::new_api_error(ApiErrorKind::Deserialize(endpoint))),
+            }
+        } else {
+            Err(Error::new_api_error(ApiErrorKind::Fetch(endpoint)))
+        }
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn get_blocking(&self, prefecture_name: &str, city_name: &str) -> Result<City, Error> {
+        let endpoint = format!("{}/{}/{}.json", self.server_url, prefecture_name, city_name);
+        let response = match reqwest::blocking::get(&endpoint) {
+            Ok(result) => result,
+            Err(_) => return Err(Error::new_api_error(ApiErrorKind::Fetch(endpoint))),
+        };
+        if response.status() == 200 {
+            match response.json::<Vec<Town>>() {
+                Ok(result) => Ok(City {
+                    name: city_name.to_string(),
+                    towns: result,
+                }),
+                Err(_) => Err(Error::new_api_error(ApiErrorKind::Deserialize(endpoint))),
+            }
+        } else {
+            Err(Error::new_api_error(ApiErrorKind::Fetch(endpoint)))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::api::city_master_api::CityMasterApi;
+    use crate::entity::Town;
+
+    #[tokio::test]
+    async fn 非同期_石川県羽咋郡志賀町_成功() {
+        let city_master_api = CityMasterApi {
+            server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+        };
+        let result = city_master_api.get("石川県", "羽咋郡志賀町").await;
+        let city = result.unwrap();
+        assert_eq!(city.name, "羽咋郡志賀町");
+        let town = Town {
+            name: "末吉".to_string(),
+            koaza: "千古".to_string(),
+            lat: Some(37.006235),
+            lng: Some(136.779155),
+        };
+        assert!(city.towns.contains(&town));
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn 同期_石川県羽咋郡志賀町_成功() {
+        let city_master_api = CityMasterApi {
+            server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+        };
+        let result = city_master_api.get_blocking("石川県", "羽咋郡志賀町");
+        let city = result.unwrap();
+        assert_eq!(city.name, "羽咋郡志賀町");
+        let town = Town {
+            name: "末吉".to_string(),
+            koaza: "千古".to_string(),
+            lat: Some(37.006235),
+            lng: Some(136.779155),
+        };
+        assert!(city.towns.contains(&town));
+    }
+
+    #[tokio::test]
+    async fn 非同期_誤った市区町村名_失敗() {
+        let city_master_api = CityMasterApi {
+            server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+        };
+        let result = city_master_api.get("石川県", "敦賀市").await;
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap().error_message,
+            format!(
+                "{}/石川県/敦賀市.jsonを取得できませんでした",
+                city_master_api.server_url
+            )
+        );
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn 同期_誤った市区町村名_失敗() {
+        let city_master_api = CityMasterApi {
+            server_url: "https://geolonia.github.io/japanese-addresses/api/ja",
+        };
+        let result = city_master_api.get_blocking("石川県", "敦賀市");
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap().error_message,
+            format!(
+                "{}/石川県/敦賀市.jsonを取得できませんでした",
+                city_master_api.server_url
+            )
+        );
+    }
+}