Change new_spice_client return type (#6)

Author: Sevenannn

src/client.rs

@@ -3,13 +3,14 @@ use arrow_flight::decode::FlightRecordBatchStream;
 use std::error::Error;
 use tonic::transport::Channel;
 
-pub async fn new_spice_client(api_key: String) -> Result<SpiceClient, Box<dyn Error>> {
+pub async fn new_spice_client(api_key: String) -> SpiceClient {
     return new_spice_client_with_address(
         api_key.to_string(),
         "https://data.spiceai.io".to_string(),
         "https://flight.spiceai.io".to_string(),
     )
-    .await;
+    .await
+    .expect("Error Initiating Client");
 }
 
 pub async fn new_spice_client_with_address(
@@ -35,7 +36,10 @@ impl SpiceClient {
             prices: PricesClient::new(Some(http_addr), api_key),
         }
     }
-    pub async fn query(&mut self, query: String) -> Result<FlightRecordBatchStream, Box<dyn Error>> {
+    pub async fn query(
+        &mut self,
+        query: String,
+    ) -> Result<FlightRecordBatchStream, Box<dyn Error>> {
         self.flight.query(query).await
     }
 }

src/flight.rs

@@ -29,7 +29,7 @@ impl SqlFlightClient {
 
     pub async fn query(
         &mut self,
-        query: String
+        query: String,
     ) -> std::result::Result<FlightRecordBatchStream, Box<dyn Error>> {
         match self.authenticate().await {
             Err(e) => return Err(e.into()),

tests/client_test.rs

@@ -8,8 +8,8 @@ mod tests {
     async fn new_client() -> Client {
         dotenv::from_path(Path::new(".env.local")).ok();
         let api_key = env::var("API_KEY").expect("API_KEY not found");
-        let result = new_spice_client(api_key).await;
-        return result.expect("Failed to new spice client");
+        let spice_client = new_spice_client(api_key).await;
+        return spice_client;
     }
 
     #[tokio::test]

tests/price_test.rs

@@ -1,15 +1,15 @@
 #[cfg(test)]
 mod tests {
+    use chrono::{TimeZone, Utc};
     use spice_rs::*;
     use std::env;
     use std::path::Path;
-    use chrono::{DateTime, Utc, TimeZone};
 
     async fn new_client() -> Client {
         dotenv::from_path(Path::new(".env.local")).ok();
         let api_key = env::var("API_KEY").expect("API_KEY not found");
-        let result = new_spice_client(api_key).await;
-        return result.expect("Failed to new spice client");
+        let spice_client = new_spice_client(api_key).await;
+        return spice_client;
     }
 
     #[tokio::test]
@@ -31,12 +31,7 @@ mod tests {
 
         let result = spice_client
             .prices
-            .get_historical_prices(
-                &[pair1, pair2],
-                start_time,
-                end_time,
-                Some("1h"),
-            )
+            .get_historical_prices(&[pair1, pair2], start_time, end_time, Some("1h"))
             .await;
         assert!(result.is_ok());
     }

tests/readme_test.rs

@@ -1,45 +1,63 @@
 #[cfg(test)]
 mod tests {
+    use chrono::{Duration, Utc};
     use spice_rs::new_spice_client;
     use std::env;
     use std::ops::{Add, Sub};
     use std::path::Path;
-    use chrono::{Duration, Utc};
 
     #[tokio::test]
     async fn test_readme() {
         dotenv::from_path(Path::new(".env.local")).ok();
         let api_key = env::var("API_KEY").expect("API_KEY not found");
-        
-        match new_spice_client(api_key).await{
-            Ok(mut client) => {
-                let data = client.query("SELECT * FROM eth.recent_blocks LIMIT 10;".to_string()).await;
-                if data.is_err() {
-                    assert!(false, "failed to query: {:#?}", data.expect_err("")) 
-                }
-                let supported_pairs = client.prices.get_supported_pairs().await;
-                if supported_pairs.is_err() {
-                    assert!(false, "failed to get supported pairs: {:#?}", supported_pairs.expect_err("")) 
-                }
-                let price_data = client.prices.get_prices(&["BTC-USDC"]).await;
-                if price_data.is_err() {
-                    assert!(false, "failed to get prices: {:#?}", price_data.expect_err("")) 
-                }
-                let historical_price_data = client.prices.get_historical_prices(&["BTC-USDC"], Option::None, Option::None, Option::None).await;
-                if historical_price_data.is_err() {
-                    assert!(false, "failed to get prices: {:#?}", historical_price_data.expect_err("")) 
-                }
-                let now = Utc::now();
-                let start = now.sub(Duration::seconds(3600));
 
-                let historical_price_data = client.prices.get_historical_prices(&["BTC-USDC"], Some(start),Some(now), Option::None).await;
-                if historical_price_data.is_err() {
-                    assert!(false, "failed to get prices: {:#?}", historical_price_data.expect_err("")) 
-                }
-            }
-            Err(e) => {
-                assert!(false, "Error: {:#?}", e);
-            }
+        let mut client = new_spice_client(api_key).await;
+        let data = client
+            .query("SELECT * FROM eth.recent_blocks LIMIT 10;".to_string())
+            .await;
+        if data.is_err() {
+            assert!(false, "failed to query: {:#?}", data.expect_err(""))
+        }
+        let supported_pairs = client.prices.get_supported_pairs().await;
+        if supported_pairs.is_err() {
+            assert!(
+                false,
+                "failed to get supported pairs: {:#?}",
+                supported_pairs.expect_err("")
+            )
+        }
+        let price_data = client.prices.get_prices(&["BTC-USDC"]).await;
+        if price_data.is_err() {
+            assert!(
+                false,
+                "failed to get prices: {:#?}",
+                price_data.expect_err("")
+            )
+        }
+        let historical_price_data = client
+            .prices
+            .get_historical_prices(&["BTC-USDC"], Option::None, Option::None, Option::None)
+            .await;
+        if historical_price_data.is_err() {
+            assert!(
+                false,
+                "failed to get prices: {:#?}",
+                historical_price_data.expect_err("")
+            )
+        }
+        let now = Utc::now();
+        let start = now.sub(Duration::seconds(3600));
+
+        let historical_price_data = client
+            .prices
+            .get_historical_prices(&["BTC-USDC"], Some(start), Some(now), Option::None)
+            .await;
+        if historical_price_data.is_err() {
+            assert!(
+                false,
+                "failed to get prices: {:#?}",
+                historical_price_data.expect_err("")
+            )
         }
-    }        
+    }
 }