printwell-pdf 0.1.5

//! Tests for PDF forms functionality

use crate::forms::*;

#[cfg(test)]
mod rect_tests {
    use super::*;

    #[test]
    fn test_default_rect() {
        let rect = Rect::default();

        assert!((rect.x - 0.0).abs() < 0.001);
        assert!((rect.y - 0.0).abs() < 0.001);
        assert!((rect.width - 0.0).abs() < 0.001);
        assert!((rect.height - 0.0).abs() < 0.001);
    }

    #[test]
    fn test_custom_rect() {
        let rect = Rect {
            x: 50.0,
            y: 100.0,
            width: 200.0,
            height: 30.0,
        };

        assert!((rect.x - 50.0).abs() < 0.001);
        assert!((rect.y - 100.0).abs() < 0.001);
        assert!((rect.width - 200.0).abs() < 0.001);
        assert!((rect.height - 30.0).abs() < 0.001);
    }

    #[test]
    fn test_rect_copy() {
        let rect = Rect {
            x: 10.0,
            y: 20.0,
            width: 30.0,
            height: 40.0,
        };
        let copy = rect;

        assert!((copy.x - 10.0).abs() < 0.001);
    }
}

#[cfg(test)]
mod text_field_tests {
    use super::*;

    #[test]
    fn test_text_field_builder_minimal() {
        let field = TextField::builder()
            .name("username")
            .page(1u32)
            .rect(Rect::default())
            .build();

        assert_eq!(field.name, "username");
        assert_eq!(field.page, 1);
        assert!(!field.flags.behavior.multiline);
        assert!(!field.flags.behavior.password);
        assert!(!field.flags.constraints.required);
        assert!(!field.flags.constraints.read_only);
    }

    #[test]
    fn test_text_field_builder_full() {
        let field = TextField::builder()
            .name("description")
            .page(2u32)
            .rect(Rect {
                x: 50.0,
                y: 100.0,
                width: 300.0,
                height: 100.0,
            })
            .default_value(Some("Default text".to_string()))
            .max_length(Some(500u32))
            .flags(TextFieldFlags {
                behavior: InputBehavior {
                    multiline: true,
                    password: false,
                },
                constraints: FieldConstraints {
                    required: true,
                    read_only: false,
                },
            })
            .font_size(14.0)
            .font_name("Times-Roman")
            .build();

        assert_eq!(field.name, "description");
        assert_eq!(field.page, 2);
        assert!(field.flags.behavior.multiline);
        assert!(field.flags.constraints.required);
        assert_eq!(field.default_value, Some("Default text".to_string()));
        assert_eq!(field.max_length, Some(500));
        assert!((field.font_size - 14.0).abs() < 0.001);
    }

    #[test]
    fn test_text_field_password() {
        let field = TextField::builder()
            .name("password")
            .page(1u32)
            .rect(Rect::default())
            .flags(TextFieldFlags {
                behavior: InputBehavior {
                    multiline: false,
                    password: true,
                },
                constraints: FieldConstraints::default(),
            })
            .build();

        assert!(field.flags.behavior.password);
    }

    #[test]
    fn test_text_field_to_ffi() {
        let field = TextField::builder()
            .name("email")
            .page(1u32)
            .rect(Rect {
                x: 10.0,
                y: 20.0,
                width: 200.0,
                height: 25.0,
            })
            .flags(TextFieldFlags {
                behavior: InputBehavior::default(),
                constraints: FieldConstraints {
                    required: true,
                    read_only: false,
                },
            })
            .build();

        let ffi = field.to_ffi();

        assert_eq!(ffi.name, "email");
        assert_eq!(ffi.page, 1);
        assert!((ffi.x - 10.0).abs() < 0.001);
        assert!((ffi.y - 20.0).abs() < 0.001);
        assert!((ffi.width - 200.0).abs() < 0.001);
        assert!((ffi.height - 25.0).abs() < 0.001);
        assert!(ffi.required);
    }
}

#[cfg(test)]
mod checkbox_tests {
    use super::*;

    #[test]
    fn test_checkbox_builder_minimal() {
        let checkbox = Checkbox::builder()
            .name("agree")
            .page(1u32)
            .rect(Rect::default())
            .build();

        assert_eq!(checkbox.name, "agree");
        assert_eq!(checkbox.page, 1);
        assert!(!checkbox.checked);
        assert_eq!(checkbox.export_value, "Yes");
    }

    #[test]
    fn test_checkbox_builder_checked() {
        let checkbox = Checkbox::builder()
            .name("newsletter")
            .page(1u32)
            .rect(Rect::default())
            .checked(true)
            .export_value("Subscribe")
            .build();

        assert!(checkbox.checked);
        assert_eq!(checkbox.export_value, "Subscribe");
    }

    #[test]
    fn test_checkbox_to_ffi() {
        let checkbox = Checkbox::builder()
            .name("terms")
            .page(2u32)
            .rect(Rect {
                x: 30.0,
                y: 400.0,
                width: 15.0,
                height: 15.0,
            })
            .checked(true)
            .build();

        let ffi = checkbox.to_ffi();

        assert_eq!(ffi.name, "terms");
        assert_eq!(ffi.page, 2);
        assert!((ffi.x - 30.0).abs() < 0.001);
        assert!((ffi.y - 400.0).abs() < 0.001);
        assert!((ffi.size - 15.0).abs() < 0.001);
        assert!(ffi.checked);
    }
}

#[cfg(test)]
mod dropdown_tests {
    use super::*;

    #[test]
    fn test_dropdown_builder_minimal() {
        let dropdown = Dropdown::builder()
            .name("country")
            .page(1u32)
            .rect(Rect::default())
            .options(vec!["USA".to_string(), "Canada".to_string()])
            .build();

        assert_eq!(dropdown.name, "country");
        assert_eq!(dropdown.options.len(), 2);
        assert_eq!(dropdown.selected_index, None);
        assert!(!dropdown.editable);
    }

    #[test]
    fn test_dropdown_with_selection() {
        let dropdown = Dropdown::builder()
            .name("language")
            .page(1u32)
            .rect(Rect::default())
            .options(vec![
                "English".to_string(),
                "Spanish".to_string(),
                "French".to_string(),
            ])
            .selected_index(Some(0))
            .build();

        assert_eq!(dropdown.selected_index, Some(0));
    }

    #[test]
    fn test_dropdown_editable() {
        let dropdown = Dropdown::builder()
            .name("other")
            .page(1u32)
            .rect(Rect::default())
            .options(vec!["Option 1".to_string()])
            .editable(true)
            .build();

        assert!(dropdown.editable);
    }

    #[test]
    fn test_dropdown_to_ffi() {
        let dropdown = Dropdown::builder()
            .name("state")
            .page(1u32)
            .rect(Rect {
                x: 100.0,
                y: 200.0,
                width: 150.0,
                height: 25.0,
            })
            .options(vec!["CA".to_string(), "NY".to_string(), "TX".to_string()])
            .selected_index(Some(1))
            .editable(false)
            .build();

        let ffi = dropdown.to_ffi();

        assert_eq!(ffi.name, "state");
        assert_eq!(ffi.options.len(), 3);
        assert_eq!(ffi.selected_index, 1);
        assert!(!ffi.editable);
    }

    #[test]
    fn test_dropdown_to_ffi_no_selection() {
        let dropdown = Dropdown::builder()
            .name("city")
            .page(1u32)
            .rect(Rect::default())
            .options(vec!["NYC".to_string()])
            .build();

        let ffi = dropdown.to_ffi();
        assert_eq!(ffi.selected_index, -1);
    }
}

#[cfg(test)]
mod signature_field_tests {
    use super::*;

    #[test]
    fn test_signature_field_builder() {
        let field = SignatureField::builder()
            .name("signature1".to_string())
            .page(3u32)
            .rect(Rect {
                x: 50.0,
                y: 700.0,
                width: 200.0,
                height: 60.0,
            })
            .build();

        assert_eq!(field.name, "signature1");
        assert_eq!(field.page, 3);
        assert!((field.rect.width - 200.0).abs() < 0.001);
        assert!((field.rect.height - 60.0).abs() < 0.001);
    }

    #[test]
    fn test_signature_field_to_ffi() {
        let field = SignatureField::builder()
            .name("sign_here".to_string())
            .page(1u32)
            .rect(Rect {
                x: 100.0,
                y: 500.0,
                width: 150.0,
                height: 50.0,
            })
            .build();

        let ffi = field.to_ffi();

        assert_eq!(ffi.name, "sign_here");
        assert_eq!(ffi.page, 1);
        assert!((ffi.x - 100.0).abs() < 0.001);
        assert!((ffi.y - 500.0).abs() < 0.001);
        assert!((ffi.width - 150.0).abs() < 0.001);
        assert!((ffi.height - 50.0).abs() < 0.001);
    }
}