From cfed349c034d15b8a2198a9cdb803518c52edfc1 Mon Sep 17 00:00:00 2001
From: bitfl0wer <florian@pro-weber.com>
Date: Sun, 23 Apr 2023 13:58:17 +0200
Subject: [PATCH] Make send_request return Result

---
 src/api/auth/register.rs |  2 +-
 src/errors.rs            |  1 +
 src/limit.rs             | 38 +++++++++++++++++++++++---------------
 3 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs
index 63c89b9..d25f7c5 100644
--- a/src/api/auth/register.rs
+++ b/src/api/auth/register.rs
@@ -31,7 +31,7 @@ pub mod register {
             let response = limited_requester
                 .send_request(request_builder, LimitType::AuthRegister)
                 .await;
-            if response.is_none() {
+            if !response.is_ok() {
                 return Err(InstanceServerError::NoResponse);
             }
 
diff --git a/src/errors.rs b/src/errors.rs
index e57d5c8..58dc856 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -17,4 +17,5 @@ custom_error! {
     ReceivedErrorCodeError{error_code:String} = "Received the following error code while requesting from the route: {error_code}",
     CantGetInfoError{error:String} = "Something seems to be wrong with the instance. Cannot get information about the instance: {error}",
     InvalidFormBodyError{error_type: String, error:String} = "The server responded with: {error_type}: {error}",
+    RateLimited = "Ratelimited.",
 }
diff --git a/src/limit.rs b/src/limit.rs
index b12069f..f5ac4b6 100644
--- a/src/limit.rs
+++ b/src/limit.rs
@@ -1,4 +1,7 @@
-use crate::api::limits::{Limit, LimitType, Limits};
+use crate::{
+    api::limits::{Limit, LimitType, Limits},
+    errors::InstanceServerError,
+};
 
 use reqwest::{Client, RequestBuilder, Response};
 use std::collections::{HashMap, VecDeque};
@@ -67,7 +70,7 @@ impl LimitedRequester {
         &mut self,
         request: RequestBuilder,
         limit_type: LimitType,
-    ) -> Option<Response> {
+    ) -> Result<Response, InstanceServerError> {
         if self.can_send_request(limit_type) {
             let built_request = request
                 .build()
@@ -78,13 +81,13 @@ impl LimitedRequester {
                 Err(e) => panic!("An error occured while processing the response: {}", e),
             };
             self.update_limits(&response, limit_type);
-            return Some(response);
+            return Ok(response);
         } else {
             self.requests.push_back(TypedRequest {
                 request: request,
                 limit_type: limit_type,
             });
-            return None;
+            return Err(InstanceServerError::RateLimited);
         }
     }
 
@@ -264,20 +267,25 @@ mod rate_limit {
             String::from("http://localhost:3001/cdn"),
         );
         let mut requester = LimitedRequester::new(urls.api.clone()).await;
-        let mut request: Option<Response>;
-        request = None;
+        let mut request: Option<Result<Response, InstanceServerError>> = None;
 
-        for _ in 0..50 {
+        for _ in 0..=50 {
             let request_path = urls.api.clone() + "/some/random/nonexisting/path";
 
             let request_builder = requester.http.get(request_path);
-            request = requester
-                .send_request(request_builder, LimitType::Channel)
-                .await;
+            request = Some(
+                requester
+                    .send_request(request_builder, LimitType::Channel)
+                    .await,
+            );
         }
-        match request {
-            Some(_) => assert!(false),
-            None => assert!(true),
+        if request.is_some() {
+            match request.unwrap() {
+                Ok(_) => assert!(false),
+                Err(_) => assert!(true),
+            }
+        } else {
+            assert!(false)
         }
     }
 
@@ -295,8 +303,8 @@ mod rate_limit {
             .send_request(request_builder, LimitType::Channel)
             .await;
         let result = match request {
-            Some(result) => result,
-            None => panic!("Request failed"),
+            Ok(result) => result,
+            Err(_) => panic!("Request failed"),
         };
         let config: Config = from_str(result.text().await.unwrap().as_str()).unwrap();
         println!("{:?}", config);