complete is_prime

src/bin/is_prime.rs

@@ -8,7 +8,7 @@ const BUFF_SIZE: usize = 1;
 #[derive(Deserialize, Debug)]
 struct Request {
     method: String,
-    number: f32
+    number: f64
 }
 
 #[derive(Serialize, Debug)]
@@ -17,6 +17,22 @@ struct Response {
     prime: bool
 }
 
+fn is_prime(n: f64) -> bool {
+    if n <= 1.0 || n.floor() != n {
+        return false;
+    }
+
+    let max_check = n.sqrt().floor() as usize;
+
+    for i in 2..=max_check {
+        let div = n / (i as f64);
+        if div == div.floor() {
+            return false;
+        }
+    }
+    true
+}
+
 fn main() -> std::io::Result<()> {
 
     let listener = TcpListener::bind(format!("0.0.0.0:{PORT}"))?;
@@ -33,26 +49,40 @@ fn main() -> std::io::Result<()> {
                             println!("{:?}", buf);
                             match buf {
                                 [10] => {
-                                    println!("got newline");
+
                                     let s = String::from_utf8(big_buf.clone()).unwrap();
+                                    big_buf.clear();
+
+                                    println!("processing: {s}");
+
                                     let d = serde_json::from_str::<Request>(&s);
+
                                     match d {
                                         Ok(message) => {
-                                            let response = Response {
+                                            match message.method.as_str() {
-                                                    method: String::from("isPrime"),
+                                                "isPrime" => {
-                                                    prime: false
+                                                    let response = Response {
-                                                };
+                                                            method: String::from("isPrime"),
-                                            let res_str = serde_json::to_string(&response).unwrap();
+                                                            prime: is_prime(message.number)
-                                            let _ = stream.write(&res_str.as_bytes());
+                                                        };
+                                                    let res_str = format!("{}\n", serde_json::to_string(&response).unwrap());
+                                                    let _ = stream.write(res_str.as_bytes());
+                                                }
+                                                s => {
+                                                    println!("received invalid method: {s}");
+                                                    let _ = stream.write(&"malformed".as_bytes());
+                                                    let _ = stream.shutdown(std::net::Shutdown::Both);
+                                                }
+                                            }
                                         },
                                         Err(e) => {
-                                            println!("Error parsing\n{:?}", e);
+                                            println!("received malformed request: {:?}", e);
+                                            let _ = stream.write(&"malformed".as_bytes());
+                                            let _ = stream.shutdown(std::net::Shutdown::Both);
                                         }
                                     }
-                                    let _ = stream.write(&buf);
                                 },
                                 [n] => {
-                                    println!("read {n}");
                                     big_buf.push(n);
                                 }
                             }
@@ -68,3 +98,19 @@ fn main() -> std::io::Result<()> {
 
     Ok(())
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::is_prime;
+    #[test]
+    fn should_return_correct_primes() {
+        assert!(!is_prime(8.0));
+        assert!(is_prime(101.0));
+        assert!(!is_prime(420.0));
+        assert!(!is_prime(7.5));
+         assert!(!is_prime(1.0));
+        assert!(is_prime(76247027.0));
+        assert!(is_prime(7.0));
+    }
+}