General cleanup and introduced tests

Author: celarye

.gitignore

@@ -1,2 +1,3 @@
 /target
+/input_examples/**
 .env

Makefile

@@ -8,6 +8,10 @@ check:
 	@echo "Checking..."
 	@cargo check
 
+test:
+	@echo "Running tests..."
+	@cargo test
+
 build_dev:
 	@echo "Building debug..."
 	@cargo build

src/days/_2.rs

@@ -49,6 +49,7 @@ impl _2 {
         let mut result = 0;
 
         for line_collection in self.collection.iter() {
+            // TODO: Fix the bug where is_valid_line_collection calls itself with a None p_invalid_number_index, correct the allowed mutation count and move the subtract with overflow check to the method call
             result += self.is_valid_line_collection(line_collection, None, 3);
         }
 

src/days/template.rs

@@ -6,15 +6,16 @@ pub fn init() -> Result<Template, ()> {
     let mut template = Template {};
 
     match utils::http::request(0) {
-        Ok(_) => (),
-        Err(()) => {
-            return Err(());
-        }
+        Ok(string) => template.parse_input(&input_string),
+        Err(()) => Err(()),
     }
-    Ok(template)
 }
 
 impl Template {
+    fn parse_input(mut self, string: &String) -> Result<Template, ()> {
+        Ok(self)
+    }
+
     fn part1(&self) -> String {
         "No Result".to_string()
     }
@@ -27,3 +28,35 @@ impl Template {
         vec![self.part1(), self.part2()]
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Template;
+
+    pub fn test_init() -> Result<Template, ()> {
+        let mut template = Template {};
+
+        match fs::read_to_string("input_examples/template.txt") {
+            Ok(input_string) => template.parse_input(&input_string),
+            Err(err) => {
+                eprintln!(
+                    "An error occurred while loading the example input: {}",
+                    &err
+                );
+                Err(())
+            }
+        }
+    }
+
+    #[test]
+    fn part1_test() {
+        let template = test_init().unwrap();
+        assert_eq!("Part 1 Example Input Result".to_string(), template.part1())
+    }
+
+    #[test]
+    fn part2_test() {
+        let mut template = test_init().unwrap();
+        assert_eq!("Part 2 Example Input Result".to_string(), template.part2())
+    }
+}

src/main.rs

@@ -1,17 +1,17 @@
-// Add tests using the example data
+// TODO: Add tests for days 1-4 using the example input
 
 use std::process::ExitCode;
 
 mod days;
 mod utils;
 
 fn main() -> ExitCode {
-    if let Err(exitcode) = utils::env::load_session_token() {
+    if let Err(exitcode) = utils::env::load_dotenv() {
         eprintln!("Exiting the program");
         return ExitCode::from(exitcode);
     }
 
-    // TODO: Allow giving a range
+    // TODO: Allow giving a range of days
     let all_results = days::results();
 
     let mut day: u8 = 1;

src/utils/env.rs

@@ -1,29 +1,15 @@
 use std::{env, fs};
 
-pub fn load_session_token() -> Result<(), u8> {
+pub fn load_dotenv() -> Result<(), u8> {
     println!("Loading all environment variables from the dotenv file...");
 
-    let p_dotenv_vec = fs::read(".env");
-
-    let dotenv_vec;
-    match p_dotenv_vec {
-        Ok(r_dotenv_vec) => dotenv_vec = r_dotenv_vec,
-        Err(err) => {
-            eprintln!("Failed to load the dotenv file, error: {}", &err);
-            return Err(0x1);
-        }
-    }
-
-    let p_dotenv_string = String::from_utf8(dotenv_vec);
+    let p_dotenv_string = fs::read_to_string(".env");
 
     let dotenv_string;
     match p_dotenv_string {
         Ok(r_dotenv_string) => dotenv_string = r_dotenv_string,
         Err(err) => {
-            eprintln!(
-                "Failed to parse the dotenv vec<u8> into a String, error: {}",
-                &err
-            );
+            eprintln!("Failed to load the dotenv file, error: {}", &err);
             return Err(0x1);
         }
     }

src/utils/http.rs

@@ -1,6 +1,6 @@
 // TODO: Replace the Curl subprocess with a basic HTTP/2 request using std::io::net
 // TODO: Prevent early fetching
-// TODO: Cache the response
+// TODO: Cache the response and use the instead cache if it is available
 
 use std::{env, process::Command};
 
@@ -17,8 +17,8 @@ pub fn request(day: u8) -> Result<String, ()> {
         .output();
 
     match p_request {
-        Ok(p_input) => match String::from_utf8(p_input.stdout) {
-            Ok(input) => match input.as_str() {
+        Ok(p_input_string) => match String::from_utf8(p_input_string.stdout) {
+            Ok(input_string) => match input_string.as_str() {
                 "Puzzle inputs differ by user.  Please log in to get your puzzle input.\n" => {
                     eprintln!("An error occurred while requesting the input: the provided session token is invalid");
                     Err(())
@@ -29,7 +29,7 @@ pub fn request(day: u8) -> Result<String, ()> {
                 }
                 _ => {
                     println!("Successfully requested the input");
-                    Ok(input)
+                    Ok(input_string)
                 }
             }
             Err(err) => {