iced_aw 0.14.1

//! Integration tests for the Sidebar and SidebarWithContent widgets
//!
//! These tests verify the widgets' behavior and public API
//! from an external perspective, testing the widgets as a user of the
//! library would interact with them.

// Test Notes:
// Button cheat sheet
//  cancel          → \u{e800}  // Used for close/cancel buttons

// Simulator API https://raw.githubusercontent.com/iced-rs/iced/master/test/src/simulator.rs

#[macro_use]
mod common;

use iced_aw::sidebar::{Sidebar, SidebarPosition, SidebarWithContent, TabLabel};
use iced_test::Error;
use iced_widget::text::Text;

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
enum TabId {
    Home,
    Settings,
    Profile,
}

#[derive(Clone, Debug)]
#[allow(dead_code)]
enum Message {
    TabSelected(TabId),
    TabClosed(TabId),
}

// Generate test helpers for this Message type
test_helpers!(Message);

// ============================================================================
// Sidebar Tests
// ============================================================================

#[test]
fn sidebar_can_find_tab_text_labels() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Text("Home".to_string()))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .push(TabId::Profile, TabLabel::Text("Profile".to_string()))
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    // Create a new simulator to verify the rendered content
    let mut ui = simulator(&app);

    // Snapshot testing: verify visual rendering matches baseline
    assert_snapshot_matches(&mut ui, "tests/snapshots/sidebar_can_find_tab_text_labels")?;

    assert!(
        ui.find("Home").is_ok(),
        "Tab label 'Home' should be findable"
    );
    assert!(
        ui.find("Settings").is_ok(),
        "Tab label 'Settings' should be findable"
    );
    assert!(
        ui.find("Profile").is_ok(),
        "Tab label 'Profile' should be findable"
    );

    Ok(())
}

#[test]
fn sidebar_clicking_tab_produces_tab_selected_message() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Text("Home".to_string()))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .push(TabId::Profile, TabLabel::Text("Profile".to_string()))
            .into()
    });

    let mut ui = simulator(&app);

    // Verify the tab is clickable
    assert!(
        ui.find("Settings").is_ok(),
        "Settings tab should be findable"
    );

    ui.click("Settings")?;

    // Process messages to verify we got TabSelected message
    assert_message_received(
        ui,
        &mut app,
        |m| matches!(m, Message::TabSelected(TabId::Settings)),
        "Clicking tab should produce TabSelected message",
    );

    Ok(())
}

#[test]
fn sidebar_can_find_different_tab_label_types() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Icon('H'))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .push(
                TabId::Profile,
                TabLabel::IconText('P', "Profile".to_string()),
            )
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Icon label
    assert!(ui.find("H").is_ok(), "Icon 'H' should be findable");

    // Text label
    assert!(
        ui.find("Settings").is_ok(),
        "Text label 'Settings' should be findable"
    );

    // IconText label
    assert!(ui.find("P").is_ok(), "Icon 'P' should be findable");
    assert!(
        ui.find("Profile").is_ok(),
        "Text 'Profile' should be findable"
    );

    Ok(())
}

#[test]
fn sidebar_with_close_callback_displays_close_icon() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Text("Home".to_string()))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .on_close(Message::TabClosed)
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Verify tabs are findable
    assert!(ui.find("Home").is_ok(), "Home tab should be findable");
    assert!(
        ui.find("Settings").is_ok(),
        "Settings tab should be findable"
    );

    Ok(())
}

// Note: The close icon test is currently not working because the icon character
// needs to be matched exactly as it appears in the font. The operate() method
// has been implemented to expose the close icon, but the simulator's find()
// may need the exact Unicode character that the font renders.
#[test]
#[ignore]
fn sidebar_clicking_close_icon_produces_tab_closed_message() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Text("Home".to_string()))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .on_close(Message::TabClosed)
            .into()
    });

    let mut ui = simulator(&app);

    // Verify the close icon is findable
    // The character \u{e800} is the cancel icon from the iced_aw font
    assert!(
        ui.find("\u{e800}").is_ok(),
        "Close icon should be findable in the sidebar"
    );

    // Click the close icon (cancel button)
    ui.click("\u{e800}")?;

    // Process messages to verify we got TabClosed message
    assert_message_received(
        ui,
        &mut app,
        |m| matches!(m, Message::TabClosed(_)),
        "Clicking close icon should produce TabClosed message",
    );

    Ok(())
}

#[test]
fn sidebar_with_close_exposes_elements_through_operate() -> Result<(), Error> {
    // This test verifies that the operate() method is being called and
    // the sidebar structure is exposed for testing
    let (mut app, _) = App::new(move || {
        Sidebar::new(Message::TabSelected)
            .push(TabId::Home, TabLabel::Text("Home".to_string()))
            .push(TabId::Settings, TabLabel::Text("Settings".to_string()))
            .on_close(Message::TabClosed)
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Verify tab labels are findable (proving operate() works)
    assert!(ui.find("Home").is_ok(), "Home tab should be findable");
    assert!(
        ui.find("Settings").is_ok(),
        "Settings tab should be findable"
    );

    Ok(())
}

// ============================================================================
// SidebarWithContent Tests
// ============================================================================

#[test]
fn sidebar_with_content_displays_tabs_and_content() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        SidebarWithContent::new(Message::TabSelected)
            .push(
                TabId::Home,
                TabLabel::Text("Home".to_string()),
                Text::new("Home Content"),
            )
            .push(
                TabId::Settings,
                TabLabel::Text("Settings".to_string()),
                Text::new("Settings Content"),
            )
            .push(
                TabId::Profile,
                TabLabel::Text("Profile".to_string()),
                Text::new("Profile Content"),
            )
            .set_active_tab(&TabId::Home)
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Verify tabs are findable
    assert!(ui.find("Home").is_ok(), "Home tab should be findable");
    assert!(
        ui.find("Settings").is_ok(),
        "Settings tab should be findable"
    );
    assert!(ui.find("Profile").is_ok(), "Profile tab should be findable");

    // Verify active tab content is displayed
    assert!(
        ui.find("Home Content").is_ok(),
        "Active tab content should be displayed"
    );

    Ok(())
}

#[test]
fn sidebar_with_content_clicking_tab_shows_new_content() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        SidebarWithContent::new(Message::TabSelected)
            .push(
                TabId::Home,
                TabLabel::Text("Home".to_string()),
                Text::new("Home Content"),
            )
            .push(
                TabId::Settings,
                TabLabel::Text("Settings".to_string()),
                Text::new("Settings Content"),
            )
            .set_active_tab(&TabId::Home)
            .into()
    });

    let mut ui = simulator(&app);

    // Verify initial content
    assert!(
        ui.find("Home Content").is_ok(),
        "Home content should be displayed initially"
    );

    // Click on Settings tab
    ui.click("Settings")?;

    // Verify we got the TabSelected message
    assert_message_received(
        ui,
        &mut app,
        |m| matches!(m, Message::TabSelected(TabId::Settings)),
        "Clicking Settings tab should produce TabSelected message",
    );

    Ok(())
}

#[test]
fn sidebar_with_content_start_position() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        SidebarWithContent::new(Message::TabSelected)
            .push(
                TabId::Home,
                TabLabel::Text("Home".to_string()),
                Text::new("Home Content"),
            )
            .push(
                TabId::Settings,
                TabLabel::Text("Settings".to_string()),
                Text::new("Settings Content"),
            )
            .sidebar_position(SidebarPosition::Start)
            .set_active_tab(&TabId::Home)
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Verify both sidebar and content are findable
    assert!(ui.find("Home").is_ok(), "Sidebar should be findable");
    assert!(
        ui.find("Home Content").is_ok(),
        "Content should be findable"
    );

    Ok(())
}

#[test]
fn sidebar_with_content_end_position() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        SidebarWithContent::new(Message::TabSelected)
            .push(
                TabId::Home,
                TabLabel::Text("Home".to_string()),
                Text::new("Home Content"),
            )
            .push(
                TabId::Settings,
                TabLabel::Text("Settings".to_string()),
                Text::new("Settings Content"),
            )
            .sidebar_position(SidebarPosition::End)
            .set_active_tab(&TabId::Home)
            .into()
    });

    let ui = simulator(&app);
    process_messages(ui, &mut app);

    let mut ui = simulator(&app);

    // Verify both sidebar and content are findable
    assert!(ui.find("Home").is_ok(), "Sidebar should be findable");
    assert!(
        ui.find("Home Content").is_ok(),
        "Content should be findable"
    );

    Ok(())
}

#[test]
fn sidebar_with_content_multiple_tab_clicks() -> Result<(), Error> {
    let (mut app, _) = App::new(move || {
        SidebarWithContent::new(Message::TabSelected)
            .push(
                TabId::Home,
                TabLabel::Text("Home".to_string()),
                Text::new("Home Content"),
            )
            .push(
                TabId::Settings,
                TabLabel::Text("Settings".to_string()),
                Text::new("Settings Content"),
            )
            .push(
                TabId::Profile,
                TabLabel::Text("Profile".to_string()),
                Text::new("Profile Content"),
            )
            .set_active_tab(&TabId::Home)
            .into()
    });

    let mut ui = simulator(&app);

    // Click Settings
    ui.click("Settings")?;

    assert_message_received(
        ui,
        &mut app,
        |m| matches!(m, Message::TabSelected(TabId::Settings)),
        "Should receive Settings tab selection",
    );

    // Create new UI and click Profile
    let mut ui = simulator(&app);
    ui.click("Profile")?;

    assert_message_received(
        ui,
        &mut app,
        |m| matches!(m, Message::TabSelected(TabId::Profile)),
        "Should receive Profile tab selection",
    );

    Ok(())
}