@oalacea/daemon 0.6.4 → 0.7.0

package/templates/rust/rocket-route.test.rs

@@ -0,0 +1,106 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rocket::http::{Header, ContentType, Status};
+    use rocket::local::blocking::Client;
+    use rocket::serde::json::Json;
+
+    /// Helper function to create test client
+    fn create_client() -> Client {
+        // TODO: Configure Rocket for testing
+        // Client::tracked(rocket().build().unwrap()).unwrap()
+        unimplemented!()
+    }
+
+    /// Test health check endpoint
+    #[test]
+    fn test_health_check() {
+        let client = create_client();
+        let response = client.get("/health").dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+    }
+
+    /// Test GET /api/users returns 200
+    #[test]
+    fn test_get_users_returns_200() {
+        let client = create_client();
+        let response = client.get("/api/users").dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+
+        // Optionally check response body
+        let body = response.into_string().unwrap();
+        assert!(!body.is_empty());
+    }
+
+    /// Test GET /api/users with authentication
+    #[test]
+    fn test_get_users_with_authentication() {
+        let client = create_client();
+        let token = "valid_token";
+
+        let response = client
+            .get("/api/users")
+            .add_header(Header::new("Authorization", format!("Bearer {}", token)))
+            .dispatch();
+
+        assert_eq!(response.status(), Status::Ok);
+    }
+
+    /// Test POST /api/users with valid data returns 201
+    #[test]
+    fn test_create_user_with_valid_data_returns_201() {
+        let client = create_client();
+        let body = serde_json::json!({
+            "name": "Test User",
+            "email": "test@example.com"
+        });
+
+        let response = client
+            .post("/api/users")
+            .header(ContentType::JSON)
+            .body(body.to_string())
+            .dispatch();
+
+        assert_eq!(response.status(), Status::Created);
+    }
+
+    /// Test POST /api/users with invalid data returns 400
+    #[test]
+    fn test_create_user_with_invalid_data_returns_400() {
+        let client = create_client();
+        let body = serde_json::json!({
+            "name": ""
+        });
+
+        let response = client
+            .post("/api/users")
+            .header(ContentType::JSON)
+            .body(body.to_string())
+            .dispatch();
+
+        assert_eq!(response.status(), Status::BadRequest);
+    }
+
+    /// TODO: Implement route handlers
+    #[get("/health")]
+    fn health_check() -> &'static str {
+        "OK"
+    }
+
+    #[get("/api/users")]
+    fn get_users() -> Json<serde_json::Value> {
+        Json(serde_json::json!([]))
+    }
+
+    #[post("/api/users", format = "json", data = "<user>")]
+    fn create_user(user: Json<serde_json::Value>) -> Status {
+        Status::Created
+    }
+
+    fn rocket() -> rocket::Rocket<rocket::Build> {
+        rocket::build()
+            .mount("/", routes![health_check, get_users, create_user])
+    }
+}

package/templates/rust/unit.test.rs

@@ -0,0 +1,38 @@
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Test that a function returns expected value
+    #[test]
+    fn test_function_returns_expected() {
+        let input = "test";
+        let result = process(input);
+        assert_eq!(result, "expected");
+    }
+
+    /// Test that a function handles empty input
+    #[test]
+    fn test_function_handles_empty_input() {
+        let input = "";
+        let result = process(input);
+        assert!(result.is_empty());
+    }
+
+    /// Test that a function handles error cases
+    #[test]
+    fn test_function_handles_errors() {
+        let input = "invalid";
+        let result = process(input);
+        assert!(result.is_err());
+    }
+
+    /// Helper function to create test fixtures
+    fn setup_test_fixture() -> String {
+        String::from("fixture")
+    }
+
+    /// TODO: Replace with actual function under test
+    fn process(input: &str) -> Result<String, Box<dyn std::error::Error>> {
+        Ok(input.to_uppercase())
+    }
+}