Function parse_example

tests/tests.rs:26–93

()

    #[test]
    fn parse_example() -> Result<(), Box<dyn std::error::Error>> {
        let content =
            std::fs::read_to_string(env::current_dir()?.join("tests/example/example.yaml"))?;

        let openapi: OpenAPI = OpenAPI::yaml(&content)?;

        // Validate general OpenAPI properties
        assert_eq!(openapi.openapi, "3.1.0");
        assert_eq!(openapi.info.title, "Example API");
        assert!(openapi.components.is_some());

        let components = openapi.components.as_ref().unwrap();

        // Validate schemas' presence of "oneOf" and "allOf"
        let schemas_check = [("ExampleRequest", false), ("ExampleResponse", false)];
        for (schema_name, expected_one_of) in schemas_check.iter() {
            let schema = components
                .schemas
                .get(*schema_name)
                .ok_or(format!("Missing schema: {}", *schema_name))?;
            assert_eq!(schema.one_of.is_some(), *expected_one_of);
        }

        let schemas_check_all_of = [("ExampleRequest", false), ("ExampleResponse", true)];
        for (schema_name, expected_all_of) in schemas_check_all_of.iter() {
            let schema = components
                .schemas
                .get(*schema_name)
                .ok_or(format!("Missing schema: {}", *schema_name))?;
            assert_eq!(schema.all_of.is_some(), *expected_all_of);
        }

        // Validate paths
        let example_path = openapi
            .paths
            .get("/example/{uuid}")
            .ok_or("Missing path: /example/{uuid}")?;
        let get_value = example_path
            .operations
            .get("get")
            .ok_or("Missing GET method for /example/{uuid}")?;

        // Validate GET parameters
        let parameter = get_value
            .parameters
            .as_ref()
            .and_then(|params| params.first())
            .ok_or("Missing parameter")?;

        // Since Parameter is now a struct, access fields directly
        assert_eq!(parameter.name.as_deref(), Some("uuid"));
        assert_eq!(
            parameter.description.as_deref(),
            Some("The UUID for this example.")
        );
        assert_eq!(parameter.r#in.as_ref(), Some(&In::Path));
        if let Some(schema) = &parameter.schema {
            assert_eq!(schema.r#type, Some(TypeOrUnion::Single(Type::String)));