check if err returned when password required but not set

Author: smacdo

crates/advent-of-code-data/src/cache.rs

@@ -15,6 +15,10 @@ use crate::{
 
 #[derive(Debug, Error)]
 pub enum CacheError {
+    #[error("AOC encryption token expected but not provided (check your config)")]
+    EncryptionTokenNotSet,
+    #[error("Cached input file is not encrypted but encryption token was provided")]
+    EncryptionTokenNotNeeded,
     #[error("base 64 decoding failed: {}", .0)]
     DecodeBase64(#[from] base64::DecodeError),
     #[error("decryption failed: {}", .0)]
@@ -116,15 +120,30 @@ impl PuzzleCache for PuzzleFsCache {
 
     fn load_input(&self, day: Day, year: Year) -> Result<String, CacheError> {
         // Load the cached input file from disk.
-        let input_path =
-            Self::input_file_path(&self.cache_dir, day, year, self.encryption_token.is_some());
-        tracing::debug!("loading input for day {day} year {year} from {input_path:?}");
+        let using_encryption = self.encryption_token.is_some();
+        let input_path = Self::input_file_path(&self.cache_dir, day, year, using_encryption);
+
+        // Check for the existence or non-existence of the input file, and hint
+        // to the user if encryption seems to be incorrectly configured.
+        if !std::fs::exists(&input_path)? {
+            let alt_input_path =
+                Self::input_file_path(&self.cache_dir, day, year, !using_encryption);
+
+            match (
+                std::fs::exists(&alt_input_path).unwrap_or(false),
+                using_encryption,
+            ) {
+                (true, false) => return Err(CacheError::EncryptionTokenNotSet),
+                (true, true) => return Err(CacheError::EncryptionTokenNotNeeded),
+                _ => {}
+            }
+        }
 
+        // Read the input file.
+        tracing::debug!("loading input for day {day} year {year} from {input_path:?}");
         let mut input_text = std::fs::read_to_string(input_path)?;
 
         // Decrypt the input data.
-        // TODO: Add error check to see if input file is encrypted and the password
-        //       token is `None` leading to encrypted input passed to puzzle.
         if let Some(encryption_token) = &self.encryption_token {
             let encrypted_bytes = BASE64_STANDARD
                 .decode(input_text.as_bytes())

tests/test_cache_fs.rs

@@ -36,6 +36,31 @@ fn persist_puzzle_input() {
     assert_eq!(&read_cached_input(Day(3), Year(2000)), "foobar");
 }
 
+#[test]
+fn try_load_unencrypted_input() {
+    let cache_dir = tempdir().unwrap();
+    let encryption_token: Option<String> = None;
+
+    // Write input data with a temporary client.
+    {
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token.clone());
+        puzzle_cache
+            .save_input("foobar", Day(19), Year(2000))
+            .unwrap();
+    }
+
+    // Read input data back with another temporary client.
+    let read_cached_input = |day: Day, year: Year| {
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token.clone());
+        puzzle_cache.try_load_input(day, year).unwrap()
+    };
+
+    assert_eq!(
+        read_cached_input(Day(19), Year(2000)),
+        Some("foobar".to_string())
+    );
+}
+
 #[test]
 fn try_load_input_exists() {
     let cache_dir = tempdir().unwrap();
@@ -83,3 +108,81 @@ fn try_load_missing_puzzle_input() {
 
     assert!(result.is_none())
 }
+
+#[test]
+fn load_input_err_if_wrong_password() {
+    let cache_dir = tempdir().unwrap();
+
+    // Write encrypted input data with a temporary client.
+    {
+        let encryption_token = Some("TEST".to_string());
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache
+            .save_input("foobar", Day(19), Year(2000))
+            .unwrap();
+    }
+
+    // Read input data back with another temporary client.
+    let read_cached_input = |day: Day, year: Year| {
+        let encryption_token = Some("wrong password".to_string());
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache.load_input(day, year)
+    };
+
+    assert!(matches!(
+        read_cached_input(Day(19), Year(2000)),
+        Err(CacheError::Decryption(_))
+    ));
+}
+
+#[test]
+fn load_input_err_if_password_missing() {
+    let cache_dir = tempdir().unwrap();
+
+    // Write encrypted input data with a temporary client.
+    {
+        let encryption_token = Some("TEST".to_string());
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache
+            .save_input("foobar", Day(19), Year(2000))
+            .unwrap();
+    }
+
+    // Read input data back with another temporary client.
+    let read_cached_input = |day: Day, year: Year| {
+        let encryption_token: Option<String> = None;
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache.load_input(day, year)
+    };
+
+    assert!(matches!(
+        read_cached_input(Day(19), Year(2000)),
+        Err(CacheError::EncryptionTokenNotSet)
+    ));
+}
+
+#[test]
+fn load_input_err_uses_unencrypted_input_if_possible() {
+    let cache_dir = tempdir().unwrap();
+
+    // Write encrypted input data with a temporary client.
+    {
+        let encryption_token: Option<String> = None;
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache
+            .save_input("foobar", Day(19), Year(2000))
+            .unwrap();
+    }
+
+    // Read input data back with another temporary client.
+    let read_cached_input = |day: Day, year: Year| {
+        let encryption_token = Some("TEST".to_string());
+        let puzzle_cache = PuzzleFsCache::new(cache_dir.path(), encryption_token);
+        puzzle_cache.load_input(day, year)
+    };
+
+    assert!(matches!(
+        read_cached_input(Day(19), Year(2000)),
+        Err(CacheError::EncryptionTokenNotNeeded)
+    ));
+}