Merge pull request #9 from coding-kelps/first-tests

First (cli, config, utils) tests

Author: guilhem-sante

.rustfmt.toml

@@ -6,8 +6,6 @@ color = "Always"
 format_strings = true
 space_after_colon = true
 
-trailling_semicolons = false
-
 # structs
 struct_field_align_threshold = 20
 struct_lit_single_line = false

Cargo.toml

@@ -2,7 +2,6 @@
 name = "leetcode-cli"
 version = "0.1.0"
 authors = ["Coding Kelps"]
-autotests = false
 categories = ["command-line-utilities"]
 description = "Interact with LeetCode in your development environment."
 edition = "2021"
@@ -14,16 +13,25 @@ readme = "README.md"
 repository = "https://github.com/coding-kelps/leetcode-cli"
 rust-version = "1.83"
 
+[[bin]]
+name = "leetcode_cli"
+path = "src/main.rs"
+
+[lib]
+name = "leetcode_cli"
+path = "src/lib.rs"
+
 [dependencies]
 leetcoderustapi = "1.0.8"
 clap = { version = "4.5.34", features = ["derive"] }
 toml = "0.8.20"
 toml_edit = "0.22.24"
 serde = { version = "1.0.219", features = ["serde_derive"] }
-reqwest = "0.12.15"
+reqwest = "0.12.18"
 tokio = { version = "1.44.1", features = ["full"] }
 dirs = "6.0.0"
 warp = "0.3.7"
 colored = "3.0.0"
 nanohtml2text = "0.2.1"
 html2md = "0.2.15"
+tempfile = "3.20.0"

src/cli.rs

@@ -35,5 +35,4 @@ pub enum Commands {
         #[arg(short = 'p', long = "file")]
         path_to_file: String,
     },
-    Debug {},
 }

src/config.rs

@@ -1,123 +1,82 @@
 use std::{
     fs,
-    io,
+    io::{
+        self,
+    },
     path::PathBuf,
 };
 
 use serde::Deserialize;
 
 #[derive(Deserialize, Debug, Clone)]
-pub struct Config {
-    home_dir:              Option<PathBuf>,
-    config_dir:            Option<PathBuf>,
-    config_file:           Option<PathBuf>,
-    pub leetcode_token:    Option<String>,
+pub struct ConfigFile {
+    pub leetcode_token:    String,
     pub default_language:  Option<String>,
     pub leetcode_dir_path: Option<PathBuf>,
 }
 
-impl Config {
+#[derive(Deserialize, Debug, Clone)]
+pub struct RuntimeConfigSetup {
+    pub home_dir:    PathBuf,
+    pub config_dir:  PathBuf,
+    pub config_file: PathBuf,
+    pub config:      ConfigFile,
+}
+
+impl RuntimeConfigSetup {
     pub fn new() -> Self {
         let home_dir =
             dirs::home_dir().expect("Unable to determine home directory");
         let config_dir = home_dir.join(".config/leetcode-cli");
         let config_file = config_dir.join("config.toml");
         let default_leetcode_dir = home_dir.join("leetcode");
 
-        Config {
-            home_dir:          Some(home_dir),
-            config_dir:        Some(config_dir),
-            config_file:       Some(config_file),
-            leetcode_token:    None,
-            default_language:  None,
-            leetcode_dir_path: Some(default_leetcode_dir),
+        RuntimeConfigSetup {
+            home_dir,
+            config_dir,
+            config_file,
+            config: ConfigFile {
+                leetcode_token:    String::new(),
+                default_language:  None,
+                leetcode_dir_path: Some(default_leetcode_dir),
+            },
         }
     }
     /// create a config file in ~/.config/leetcode-cli/config.toml
     fn create_config_file(&self) {
-        let config_dir =
-            self.config_dir.as_ref().expect("Config directory not set");
-
-        std::fs::create_dir_all(&config_dir)
+        std::fs::create_dir_all(&self.config_dir)
             .expect("Unable to create directory");
-        let config_file = config_dir.join("config.toml");
+        let config_file = self.config_dir.join("config.toml");
         std::fs::File::create(&config_file).expect("Unable to create file");
     }
     /// check for a config file in ~/.config/leetcode-cli/config.toml
-    /// read it or create it if it doesn't exist with default values
+    /// read it or create it with default values if it doesn't exist
     /// load the config in Config struct and check if the token is valid
-    /// if the token is not valid, generate a new one
-    pub async fn status(&mut self) -> Result<(), reqwest::Error> {
-        if self.config_file.is_some() {
-            let config_file =
-                std::fs::read_to_string(self.config_file.as_ref().unwrap())
-                    .expect("Unable to read file");
-            let config: Config =
-                toml::from_str(&config_file).expect("Unable to parse file");
-            self.leetcode_token = config.leetcode_token;
-            self.default_language = config.default_language;
-            if let Some(custom) = config.leetcode_dir_path {
-                self.leetcode_dir_path = Some(PathBuf::from(custom));
+    pub fn status(&mut self) -> Result<(), io::Error> {
+        if self.config_file.is_file() {
+            let config_file = std::fs::read_to_string(&self.config_file)
+                .expect("Unable to read file");
+            let parsed_config: ConfigFile =
+                toml::from_str(&config_file).expect("Unable to parse config");
+            if !parsed_config.leetcode_token.is_empty() {
+                self.config.leetcode_token = parsed_config.leetcode_token;
+            }
+            if parsed_config.default_language.is_some() {
+                self.config.default_language = parsed_config.default_language;
+            }
+            if parsed_config.leetcode_dir_path.is_some() {
+                self.config.leetcode_dir_path = parsed_config.leetcode_dir_path;
             }
-            self.check_token().await?;
         } else {
             self.create_config_file();
-            self.generate_token();
         }
         Ok(())
     }
 
-    async fn test_token_validity(&self) -> Result<bool, reqwest::Error> {
-        let token = self.leetcode_token.as_ref().unwrap();
-        let url = format!(
-            "https://leetcode.com/api/user/check_token/?token={}",
-            token
-        );
-        let response = reqwest::get(&url).await.unwrap();
-        if response.status().is_success() {
-            return Ok(true);
-        }
-        Ok(false)
-    }
-
-    async fn check_token(&mut self) -> Result<bool, reqwest::Error> {
-        let token = self.leetcode_token.as_ref();
-        if token.is_none() {
-            println!("Leetcode token not found");
-            println!("Let's set it together.");
-            self.generate_token();
-            return Ok(true);
-        }
-        self.test_token_validity().await
-    }
-
-    /// Generate a new LeetCode token by prompting the user to visit the
-    /// LeetCode login page and copy the token
-    fn generate_token(&mut self) {
-        unimplemented!(
-            "generating token is not implemented yet. Refer to the README for \
-             instructions."
-        );
-        println!("Generating token...");
-        println!("Please visit https://leetcode.com/submissions/#/1");
-        println!("and copy the token here:");
-        let mut token = String::new();
-        std::io::stdin()
-            .read_line(&mut token)
-            .expect("Failed to read line");
-        let token = token.trim();
-        if token.is_empty() {
-            println!("Token cannot be empty");
-            return;
-        }
-        self.leetcode_token = Some(token.to_string());
-        println!("Token set to: {}", token);
-    }
-
     /// Resolve the configured LeetCode directory, expand ~, canonicalize, and
     /// create if missing.
     pub fn resolve_leetcode_dir(&self) -> io::Result<PathBuf> {
-        let raw = if let Some(ref custom) = self.leetcode_dir_path {
+        let raw = if let Some(ref custom) = self.config.leetcode_dir_path {
             custom.to_string_lossy()
         } else {
             return Err(io::Error::new(
@@ -127,22 +86,14 @@ impl Config {
         };
         let raw_str = raw.as_ref();
         let mut path = if raw_str == "~" {
-            self.home_dir.clone().ok_or(io::Error::new(
-                io::ErrorKind::NotFound,
-                "Unable to find home directory",
-            ))?
+            self.home_dir.clone()
         } else if raw_str.starts_with("~/") {
-            let home = dirs::home_dir().ok_or(io::Error::new(
-                io::ErrorKind::NotFound,
-                "Unable to find home directory",
-            ))?;
+            let home = self.home_dir.clone();
             home.join(&raw_str[2..])
         } else {
             PathBuf::from(raw_str)
         };
-        // Canonicalize parent to normalize .. and . components
         path = fs::canonicalize(&path).unwrap_or(path);
-        // Ensure directory exists
         fs::create_dir_all(&path)?;
         Ok(path)
     }

src/leetcode_api_runner.rs

@@ -8,7 +8,7 @@ use leetcoderustapi::{
 use nanohtml2text::html2text;
 
 use crate::{
-    config::Config,
+    config::RuntimeConfigSetup,
     utils::{
         self,
         ensure_directory_exists,
@@ -18,16 +18,15 @@ use crate::{
 };
 
 pub struct LeetcodeApiRunner {
-    config: Config,
-    api:    UserApi,
+    rcs: RuntimeConfigSetup,
+    api: UserApi,
 }
 
 impl LeetcodeApiRunner {
-    pub async fn new(config: &mut Config) -> Self {
-        let token = config.leetcode_token.take().unwrap();
-        let api = UserApi::new(&token).await.unwrap();
+    pub async fn new(rcs: RuntimeConfigSetup) -> Self {
+        let api = UserApi::new(&rcs.config.leetcode_token).await.unwrap();
         LeetcodeApiRunner {
-            config: config.clone(),
+            rcs,
             api,
         }
     }
@@ -72,7 +71,7 @@ impl LeetcodeApiRunner {
     fn prepare_problem_directory(
         &self, id: u32, pb_name: &str, language: &ProgrammingLanguage,
     ) -> io::Result<std::path::PathBuf> {
-        let leetcode_dir = self.config.resolve_leetcode_dir()?;
+        let leetcode_dir = self.rcs.resolve_leetcode_dir()?;
         let problem_dir = leetcode_dir.join(format!("{}_{}", id, pb_name));
         ensure_directory_exists(&problem_dir)?;
 

src/lib.rs

@@ -0,0 +1,11 @@
+pub mod cli;
+pub mod config;
+pub mod leetcode_api_runner;
+pub mod utils;
+
+pub use cli::{
+    Cli,
+    Commands,
+};
+pub use config::RuntimeConfigSetup;
+pub use leetcode_api_runner::LeetcodeApiRunner;

src/main.rs

@@ -1,22 +1,18 @@
-mod cli;
-mod config;
-mod leetcode_api_runner;
-mod utils;
-
 use clap::Parser;
-use cli::{
+use leetcode_cli::{
+    utils,
     Cli,
     Commands,
+    LeetcodeApiRunner,
+    RuntimeConfigSetup,
 };
-use config::Config;
-use leetcode_api_runner::LeetcodeApiRunner;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let cli = Cli::parse();
-    let mut config = Config::new();
-    config.status().await?;
-    let api_runner = LeetcodeApiRunner::new(&mut config).await;
+    let mut rcs = RuntimeConfigSetup::new();
+    rcs.status()?;
+    let api_runner = LeetcodeApiRunner::new(rcs).await;
 
     match &cli.command {
         Commands::Info {
@@ -51,9 +47,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 .await?;
             println!("Submit result: {}", submit_result);
         },
-        Commands::Debug {} => {
-            println!("{:#?}", config.clone());
-        },
     }
     Ok(())
 }