From 8ddfa7db86155ac4a7102706b328f53b6dab2d6a Mon Sep 17 00:00:00 2001
From: Scott Jackson <scottmmjackson@gmail.com>
Date: Wed, 13 Sep 2023 08:58:46 -0400
Subject: [PATCH] Fix change to 200 not notifying

---
 Cargo.lock  |   1 +
 Cargo.toml  |   3 +-
 src/main.rs | 105 +++++++++++++++++++++++++++++++++-------------------
 3 files changed, 70 insertions(+), 39 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 005bb9e..d72d411 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -957,6 +957,7 @@ name = "upnotify"
 version = "0.1.1"
 dependencies = [
  "clap",
+ "http",
  "reqwest",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 1ce63f1..d7eaae1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,14 @@
 [package]
 name = "upnotify"
 description = "A tool that prints to stdout when the status of a URL changes."
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 reqwest = { version = "0.11.20", features = ["blocking", "native-tls-vendored"] }
+http = "0.2"
 clap = { version = "4.4.0", features = ["cargo"] }
 
 [[bin]]
diff --git a/src/main.rs b/src/main.rs
index fa9994d..566214e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -31,49 +31,78 @@ fn main() {
     let mut previous_status_option: Result = Result::None;
 
     loop {
-        match client.get(url).send() {
-            Ok(result) => {
-                let status_code = result.status();
-                match previous_status_option {
-                    Result::StatusCode(previous_status)
-                    if status_code.as_u16() != previous_status.as_u16() => {
-                        println!("Status changed to {:?}", status_code)
-                    }
-                    Result::None => {
-                        println!("Status changed to {:?}", status_code)
-                    }
-                    _ => {}
+        let response = dbg!(client.get(url).send());
+        previous_status_option = request_loop(response, previous_status_option);
+        sleep(Duration::from_secs(5));
+    }
+}
+
+fn request_loop(response: reqwest::Result<reqwest::blocking::Response>,
+                previous_status_option: Result) -> Result {
+    return match response {
+        Ok(result) => {
+            let status_code = result.status();
+            match previous_status_option {
+                Result::StatusCode(previous_status)
+                if status_code.as_u16() != previous_status.as_u16() => {
+                    println!("Status changed to {:?}", status_code)
                 }
-                previous_status_option = Result::StatusCode(status_code);
+                Result::None | Result::TimeoutError(_) | Result::ConnectError(_) |
+                Result::RequestError(_) | Result::OtherError(_) => {
+                    println!("Status changed to {:?}", status_code)
+                }
+                _ => {}
             }
-            Err(error) => {
-                match previous_status_option {
-                    Result::ConnectError(_error) if error.is_connect() => {}
-                    Result::TimeoutError(_error) if error.is_timeout() => {}
-                    Result::RequestError(_error) if error.is_request() => {}
-                    _ => {
-                        if error.is_connect() {
-                            println!("Status changed to connection failed");
-                        } else if error.is_timeout() {
-                            println!("Status changed to timed out");
-                        } else if error.is_request() {
-                            println!("Status changed to request error");
-                        } else {
-                            println!("Error: {}", error);
-                        }
+            Result::StatusCode(status_code)
+        }
+        Err(error) => {
+            match previous_status_option {
+                Result::ConnectError(_error) if error.is_connect() => {}
+                Result::TimeoutError(_error) if error.is_timeout() => {}
+                Result::RequestError(_error) if error.is_request() => {}
+                _ => {
+                    if error.is_connect() {
+                        println!("Status changed to connection failed");
+                    } else if error.is_timeout() {
+                        println!("Status changed to timed out");
+                    } else if error.is_request() {
+                        println!("Status changed to request error");
+                    } else {
+                        println!("Error: {}", error);
                     }
                 }
-                previous_status_option = if error.is_connect() {
-                    Result::ConnectError(error)
-                } else if error.is_timeout() {
-                    Result::TimeoutError(error)
-                } else if error.is_request() {
-                    Result::RequestError(error)
-                } else {
-                    Result::OtherError(error)
-                }
+            }
+            if error.is_connect() {
+                Result::ConnectError(error)
+            } else if error.is_timeout() {
+                Result::TimeoutError(error)
+            } else if error.is_request() {
+                Result::RequestError(error)
+            } else {
+                Result::OtherError(error)
             }
         }
-        sleep(Duration::from_secs(5));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use reqwest::blocking::Response;
+    use http::{Response as HttpResponse, StatusCode};
+    use crate::request_loop;
+    use crate::Result;
+
+    #[test]
+    fn test_request_loop() {
+        // Unfortunately, reqwest doesn't really let us mock results :(
+        let result200 = reqwest::Result::Ok(Response::from(
+            HttpResponse::builder().status(StatusCode::OK).body("").unwrap()
+        ));
+        let result = request_loop(result200,
+                         Result::StatusCode(StatusCode::NOT_FOUND));
+        match result {
+            Result::StatusCode(StatusCode::OK) => {  /* ok */ },
+                _ => { panic!("Unexpected status code!", )}
+        }
     }
 }