feat(generator): check if glob pattern is valid

src/generator.rs

@@ -64,8 +64,15 @@ impl Generator {
 
             Source::GlobPattern(pattern) => {
                 let mut raw_schemas = vec![];
-                for entry in glob::glob(pattern)? {
-                    let path = entry.map_err(|e| e.into_error())?;
+                let mut paths = glob::glob(pattern)?.peekable();
+                if paths.peek().is_none() {
+                    return Err(Error::GlobPattern(glob::PatternError {
+                        pos: 0,
+                        msg: "No files with the given glob pattern were found",
+                    }));
+                }
+                for path in paths {
+                    let path = path.map_err(|e| e.into_error())?;
                     if !path.is_dir() {
                         raw_schemas.push(fs::read_to_string(path)?);
                     }

tests/generation.rs

@@ -3,19 +3,25 @@ mod schemas;
 
 use apache_avro::schema::Name;
 use pretty_assertions::assert_eq;
-use rsgen_avro::{FieldOverride, Generator, ImplementAvroSchema, Source};
+use rsgen_avro::{Error, FieldOverride, Generator, ImplementAvroSchema, Result, Source};
 
 fn validate_generation(file_name: &str, g: Generator) {
-    let schema = format!("tests/schemas/{file_name}.avsc");
-    let src = Source::GlobPattern(&schema);
-    let mut buf = vec![];
-    g.generate(&src, &mut buf).unwrap();
+    let buf = generate(file_name, g).unwrap();
 
     let generated = String::from_utf8(buf).unwrap();
     let expected = std::fs::read_to_string(format!("tests/schemas/{file_name}.rs")).unwrap();
     validate(expected, generated)
 }
 
+fn generate(file_name: &str, g: Generator) -> Result<Vec<u8>> {
+    let schema = format!("tests/schemas/{file_name}.avsc");
+    let src = Source::GlobPattern(&schema);
+    let mut buf = vec![];
+    g.generate(&src, &mut buf)?;
+
+    Ok(buf)
+}
+
 fn validate(expected: String, generated: String) {
     assert_eq!(
         expected, generated,
@@ -329,3 +335,10 @@ fn gen_two_extra_derives() {
             .unwrap(),
     );
 }
+
+#[test]
+fn gen_invalid_schema_file_should_err() {
+    let error = generate("no/schema/is/found*.avsc", Generator::new().unwrap()).unwrap_err();
+
+    assert!(matches!(error, Error::GlobPattern(..)));
+}