add tests

Author: matoous

crates/weaver_common/src/test.rs

@@ -5,7 +5,7 @@
 use paris::error;
 use std::path::PathBuf;
 
-use rouille::{match_assets, Server};
+use rouille::{match_assets, Response, Server};
 use std::sync::mpsc::Sender;
 
 /// An error that can occur while starting the HTTP server.
@@ -33,13 +33,41 @@ impl ServeStaticFiles {
     /// Creates a new HTTP server that serves static files from a directory.
     /// Note: This server is only available for testing purposes.
     pub fn from(static_path: impl Into<PathBuf>) -> Result<Self, HttpServerError> {
+        Self::from_impl(static_path, None)
+    }
+
+    /// Same as [`Self::from`], but requires `Authorization: Bearer <token>` on every request.
+    /// Note: This server is only available for testing purposes.
+    pub fn from_with_bearer(
+        static_path: impl Into<PathBuf>,
+        token: impl Into<String>,
+    ) -> Result<Self, HttpServerError> {
+        Self::from_impl(static_path, Some(token.into()))
+    }
+
+    /// Internal helper to keep the original implementation effectively intact.
+    fn from_impl(
+        static_path: impl Into<PathBuf>,
+        token: Option<String>,
+    ) -> Result<Self, HttpServerError> {
         let static_path = static_path.into();
+
         let server = Server::new("127.0.0.1:0", move |request| {
+            if let Some(token) = token.as_ref() {
+                if !request
+                    .header("Authorization")
+                    .map(|h| h == format!("Bearer {}", token))
+                    .unwrap_or(false)
+                {
+                    return Response::text("Unauthorized").with_status_code(401);
+                }
+            }
             match_assets(request, &static_path)
         })
         .map_err(|e| HttpServerError {
             error: e.to_string(),
         })?;
+
         let port = server.server_addr().port();
         let (_, kill_switch) = server.stoppable();
         Ok(Self { kill_switch, port })
@@ -93,4 +121,27 @@ mod tests {
         assert!(result.is_err());
         assert!(matches!(result.unwrap_err(), ureq::Error::Status(404, _)));
     }
+
+    #[test]
+    fn test_http_server_with_bearer_auth() {
+        let token = "token";
+        let server = ServeStaticFiles::from_with_bearer("tests/test_data", token).unwrap();
+
+        let resp = ureq::get(&server.relative_path_to_url("file_a.yaml")).call();
+        assert!(resp.is_err());
+        assert!(matches!(resp.unwrap_err(), ureq::Error::Status(401, _)));
+
+        let resp = ureq::get(&server.relative_path_to_url("file_a.yaml"))
+            .set("Authorization", "wrong_token")
+            .call();
+        assert!(resp.is_err());
+        assert!(matches!(resp.unwrap_err(), ureq::Error::Status(401, _)));
+
+        let content = ureq::get(&server.relative_path_to_url("file_a.yaml"))
+            .set("Authorization", &format!("Bearer {}", token))
+            .call()
+            .unwrap();
+        assert_eq!(content.status(), 200);
+        assert_eq!(content.into_string().unwrap(), "file: A");
+    }
 }

crates/weaver_common/src/vdir.rs

@@ -875,8 +875,12 @@ mod tests {
         assert!(repo_path.exists());
     }
 
-    fn check_archive(vdir_path: VirtualDirectoryPath, file_to_check: Option<&str>) {
-        let repo = VirtualDirectory::try_new(&vdir_path, None).unwrap();
+    fn check_archive(
+        vdir_path: VirtualDirectoryPath,
+        file_to_check: Option<&str>,
+        auth_token: Option<&String>,
+    ) {
+        let repo = VirtualDirectory::try_new(&vdir_path, auth_token).unwrap();
         let repo_path = repo.path().to_path_buf();
         // At this point, the repo should be cloned into a temporary directory.
         assert!(repo_path.exists());
@@ -902,23 +906,23 @@ mod tests {
             sub_folder: Some("model".to_owned()),
             refspec: None,
         };
-        check_archive(registry_path, None);
+        check_archive(registry_path, None, None);
     }
 
     #[test]
     fn test_semconv_registry_local_tar_gz_archive() {
         let registry_path = "../../test_data/semantic-conventions-1.26.0.tar.gz[model]"
             .parse::<VirtualDirectoryPath>()
             .unwrap();
-        check_archive(registry_path, Some("general.yaml"));
+        check_archive(registry_path, Some("general.yaml"), None);
     }
 
     #[test]
     fn test_semconv_registry_local_zip_archive() {
         let registry_path = "../../test_data/semantic-conventions-1.26.0.zip[model]"
             .parse::<VirtualDirectoryPath>()
             .unwrap();
-        check_archive(registry_path, Some("general.yaml"));
+        check_archive(registry_path, Some("general.yaml"), None);
     }
 
     #[test]
@@ -930,7 +934,7 @@ mod tests {
         )
         .parse::<VirtualDirectoryPath>()
         .unwrap();
-        check_archive(registry_path, Some("general.yaml"));
+        check_archive(registry_path, Some("general.yaml"), None);
     }
 
     #[test]
@@ -942,6 +946,23 @@ mod tests {
         )
         .parse::<VirtualDirectoryPath>()
         .unwrap();
-        check_archive(registry_path, Some("general.yaml"));
+        check_archive(registry_path, Some("general.yaml"), None);
+    }
+
+    #[test]
+    fn test_semconv_registry_authentication() {
+        let token = "token";
+        let server = ServeStaticFiles::from_with_bearer("tests/test_data", token).unwrap();
+        let registry_path = format!(
+            "{}[model]",
+            server.relative_path_to_url("semconv_registry_v1.26.0.zip")
+        )
+        .parse::<VirtualDirectoryPath>()
+        .unwrap();
+        check_archive(
+            registry_path,
+            Some("general.yaml"),
+            Some(&token.to_string()),
+        );
     }
 }