Merge pull request #23 from LilyFoote/test-filesystem-loader

Add tests for FileSystemLoader and improve errors

Author: LilyFoote

src/loaders.rs

@@ -2,11 +2,12 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use encoding_rs::Encoding;
+use pyo3::exceptions::PyUnicodeError;
 use pyo3::prelude::*;
 
 use crate::template::django_rusty_templates::Template;
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LoaderError {
     pub tried: Vec<(String, String)>,
 }
@@ -30,7 +31,11 @@ impl FileSystemLoader {
         }
     }
 
-    fn get_template(&self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    fn get_template(
+        &self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         let mut tried = Vec::new();
         for template_dir in &self.dirs {
             let path = match safe_join(template_dir, template_name) {
@@ -47,7 +52,13 @@ impl FileSystemLoader {
                     continue;
                 }
             };
-            let (contents, _, _) = self.encoding.decode(&bytes);
+            let (contents, encoding, malformed) = self.encoding.decode(&bytes);
+            if malformed {
+                return Ok(Err(PyUnicodeError::new_err(format!(
+                    "Could not open {path:?} with {} encoding.",
+                    encoding.name()
+                ))));
+            }
             return Ok(Template::new(&contents, path));
         }
         Err(LoaderError { tried })
@@ -57,7 +68,11 @@ impl FileSystemLoader {
 pub struct AppDirsLoader {}
 
 impl AppDirsLoader {
-    fn get_template(&self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    fn get_template(
+        &self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         todo!()
     }
 }
@@ -75,14 +90,18 @@ impl CachedLoader {
         }
     }
 
-    fn get_template(&mut self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    fn get_template(
+        &mut self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         match self.cache.get(template_name) {
             Some(Ok(template)) => Ok(Ok(template.clone())),
             Some(Err(e)) => Err(e.clone()),
             None => {
                 let mut tried = Vec::new();
                 for loader in &mut self.loaders {
-                    match loader.get_template(template_name) {
+                    match loader.get_template(py, template_name) {
                         Ok(Ok(template)) => {
                             self.cache
                                 .insert(template_name.to_string(), Ok(template.clone()));
@@ -101,15 +120,23 @@ impl CachedLoader {
 pub struct LocMemLoader {}
 
 impl LocMemLoader {
-    fn get_template(&self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    fn get_template(
+        &self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         todo!()
     }
 }
 
 pub struct ExternalLoader {}
 
 impl ExternalLoader {
-    fn get_template(&self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    fn get_template(
+        &self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         todo!()
     }
 }
@@ -123,13 +150,75 @@ pub enum Loader {
 }
 
 impl Loader {
-    pub fn get_template(&mut self, template_name: &str) -> Result<PyResult<Template>, LoaderError> {
+    pub fn get_template(
+        &mut self,
+        py: Python<'_>,
+        template_name: &str,
+    ) -> Result<PyResult<Template>, LoaderError> {
         match self {
-            Self::FileSystem(loader) => loader.get_template(template_name),
-            Self::AppDirs(loader) => loader.get_template(template_name),
-            Self::Cached(loader) => loader.get_template(template_name),
-            Self::LocMem(loader) => loader.get_template(template_name),
-            Self::External(loader) => loader.get_template(template_name),
+            Self::FileSystem(loader) => loader.get_template(py, template_name),
+            Self::AppDirs(loader) => loader.get_template(py, template_name),
+            Self::Cached(loader) => loader.get_template(py, template_name),
+            Self::LocMem(loader) => loader.get_template(py, template_name),
+            Self::External(loader) => loader.get_template(py, template_name),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filesystem_loader() {
+        pyo3::prepare_freethreaded_python();
+
+        Python::with_gil(|py| {
+            let loader =
+                FileSystemLoader::new(vec!["tests/templates".to_string()], encoding_rs::UTF_8);
+            let template = loader.get_template(py, "basic.txt").unwrap().unwrap();
+
+            assert_eq!(
+                template.filename.unwrap(),
+                PathBuf::from("tests/templates/basic.txt")
+            );
+        })
+    }
+
+    #[test]
+    fn test_filesystem_loader_missing_template() {
+        pyo3::prepare_freethreaded_python();
+
+        Python::with_gil(|py| {
+            let loader =
+                FileSystemLoader::new(vec!["tests/templates".to_string()], encoding_rs::UTF_8);
+            let error = loader.get_template(py, "missing.txt").unwrap_err();
+
+            assert_eq!(
+                error,
+                LoaderError {
+                    tried: vec![(
+                        "tests/templates/missing.txt".to_string(),
+                        "Source does not exist".to_string(),
+                    )],
+                },
+            );
+        })
+    }
+
+    #[test]
+    fn test_filesystem_loader_invalid_encoding() {
+        pyo3::prepare_freethreaded_python();
+
+        Python::with_gil(|py| {
+            let loader =
+                FileSystemLoader::new(vec!["tests/templates".to_string()], encoding_rs::UTF_8);
+            let error = loader.get_template(py, "invalid.txt").unwrap().unwrap_err();
+
+            assert_eq!(
+                error.to_string(),
+                "UnicodeError: Could not open \"tests/templates/invalid.txt\" with UTF-8 encoding."
+            );
+        })
+    }
+}

src/template.rs

@@ -106,10 +106,10 @@ pub mod django_rusty_templates {
             })
         }
 
-        fn get_template(&mut self, template_name: String) -> PyResult<Template> {
+        fn get_template(&mut self, py: Python<'_>, template_name: String) -> PyResult<Template> {
             let mut tried = Vec::new();
             for loader in &mut self.template_loaders {
-                match loader.get_template(&template_name) {
+                match loader.get_template(py, &template_name) {
                     Ok(template) => return template,
                     Err(e) => tried.push(e.tried),
                 }
@@ -118,12 +118,12 @@ pub mod django_rusty_templates {
         }
     }
 
-    #[derive(Clone)]
+    #[derive(Clone, Debug)]
     #[pyclass]
     pub struct Template {
-        filename: Option<PathBuf>,
-        template: String,
-        nodes: Vec<TokenTree>,
+        pub filename: Option<PathBuf>,
+        pub template: String,
+        pub nodes: Vec<TokenTree>,
     }
 
     impl Template {

tests/templates/invalid.txt

@@ -0,0 +1 @@
+�(�