Function test_complex_nested_directives

aiscript-directive/src/lib.rs:344–403

()

    #[test]
    fn test_complex_nested_directives() {
        let directive = parse_single_directive(
            r#"@group(
                @validate(min=1, max=10),
                @format([1, 2, 3]),
                @nested(@check(value=true))
            )"#,
        )
        .unwrap();

        assert_eq!(directive.name, "group");
        match directive.params {
            DirectiveParams::Directives(directives) => {
                assert_eq!(directives.len(), 3);

                // First nested directive
                let validate = &directives[0];
                assert_eq!(validate.name, "validate");
                match &validate.params {
                    DirectiveParams::KeyValue(params) => {
                        assert_eq!(params.get("min").unwrap(), &json!(1));
                        assert_eq!(params.get("max").unwrap(), &json!(10));
                    }
                    _ => panic!("Expected KeyValue parameters for validate"),
                }

                // Second nested directive
                let format = &directives[1];
                assert_eq!(format.name, "format");
                match &format.params {
                    DirectiveParams::Array(values) => {
                        assert_eq!(values.len(), 3);
                        assert_eq!(values[0], json!(1));
                        assert_eq!(values[1], json!(2));
                        assert_eq!(values[2], json!(3));
                    }
                    _ => panic!("Expected Array parameters for format"),
                }

                // Third nested directive with its own nested directive
                let nested = &directives[2];
                assert_eq!(nested.name, "nested");
                match &nested.params {
                    DirectiveParams::Directives(inner) => {
                        assert_eq!(inner.len(), 1);
                        let check = &inner[0];
                        assert_eq!(check.name, "check");
                        match &check.params {
                            DirectiveParams::KeyValue(params) => {
                                assert_eq!(params.get("value").unwrap(), &json!(true));
                            }
                            _ => panic!("Expected KeyValue parameters for check"),
                        }
                    }
                    _ => panic!("Expected Directives parameters for nested"),
                }
            }
            _ => panic!("Expected Directives parameters"),