test:

    name: Test

    runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v6

        with:

          submodules: recursive

      - name: Install Rust toolchain

        uses: dtolnay/rust-toolchain@stable

      - name: Cache cargo registry & build

        uses: actions/cache@v4

        with:

          path: |

            ~/.cargo/registry

            ~/.cargo/git

            target

          key: ${{ runner.os }}-cargo-test-${{ hashFiles('**/Cargo.lock') }}

          restore-keys: |

            ${{ runner.os }}-cargo-test-

      - name: cargo test

        run: cargo test --workspace

 "tempfile",

# Testing

tempfile = "3"

#[cfg(test)]

mod tests {

    use super::*;

    fn test_db() -> Db {

        let conn = Connection::open_in_memory().unwrap();

        conn.execute_batch(

            "CREATE TABLE IF NOT EXISTS wines (

                id              INTEGER PRIMARY KEY AUTOINCREMENT,

                short_id        TEXT NOT NULL UNIQUE,

                name            TEXT NOT NULL,

                origin          TEXT NOT NULL,

                grape           TEXT NOT NULL,

                notes           TEXT NOT NULL,

                image           BLOB,

                image_mime      TEXT,

                sweetness       INTEGER NOT NULL CHECK(sweetness BETWEEN 1 AND 5),

                acidity         INTEGER NOT NULL CHECK(acidity BETWEEN 1 AND 5),

                tannin          INTEGER NOT NULL CHECK(tannin BETWEEN 1 AND 5),

                alcohol         INTEGER NOT NULL CHECK(alcohol BETWEEN 1 AND 5),

                body            INTEGER NOT NULL CHECK(body BETWEEN 1 AND 5),

                clarity         INTEGER NOT NULL DEFAULT 3,

                color_intensity INTEGER NOT NULL DEFAULT 3,

                aroma_intensity INTEGER NOT NULL DEFAULT 3,

                nose_complexity INTEGER NOT NULL DEFAULT 3,

                background      TEXT NOT NULL DEFAULT '',

                created_at      TEXT NOT NULL DEFAULT (datetime('now')),

                wishlist        INTEGER NOT NULL DEFAULT 0

            );

            CREATE TABLE IF NOT EXISTS sessions (

                id         INTEGER PRIMARY KEY AUTOINCREMENT,

                token      TEXT NOT NULL UNIQUE,

                expires_at TEXT NOT NULL

            );",

        )

        .unwrap();

        Arc::new(Mutex::new(conn))

    }

    fn create_test_wine(db: &Db, name: &str, wishlist: bool) -> Wine {

        create_wine(

            db, name, "France", "Merlot", "Smooth", None, None,

            3, 3, 3, 3, 3, 3, 3, 3, 3, "", wishlist,

        )

        .unwrap()

    }

    // ── Wine CRUD ──────────────────────────────────────────────────────

    #[test]

    fn create_and_get_wine() {

        let db = test_db();

        let wine = create_test_wine(&db, "Chateau Test", false);

        assert_eq!(wine.name, "Chateau Test");

        assert_eq!(wine.origin, "France");

        assert!(!wine.wishlist);

        let fetched = get_wine_by_short_id(&db, &wine.short_id).unwrap().unwrap();

        assert_eq!(fetched.name, "Chateau Test");

    }

    #[test]

    fn create_wine_invalid_sweetness_fails() {

        let db = test_db();

        let result = create_wine(

            &db, "Bad", "X", "X", "X", None, None,

            6, 3, 3, 3, 3, 3, 3, 3, 3, "", false, // sweetness=6 > 5

        );

        assert!(result.is_err());

    }

    #[test]

    fn create_wine_zero_rating_fails() {

        let db = test_db();

        let result = create_wine(

            &db, "Bad", "X", "X", "X", None, None,

            0, 3, 3, 3, 3, 3, 3, 3, 3, "", false, // sweetness=0 < 1

        );

        assert!(result.is_err());

    }

    #[test]

    fn get_cellar_wines_excludes_wishlist() {

        let db = test_db();

        create_test_wine(&db, "Cellar Wine", false);

        create_test_wine(&db, "Wishlist Wine", true);

        let cellar = get_cellar_wines(&db).unwrap();

        assert_eq!(cellar.len(), 1);

        assert_eq!(cellar[0].name, "Cellar Wine");

    }

    #[test]

    fn get_wishlist_wines_only_wishlist() {

        let db = test_db();

        create_test_wine(&db, "Cellar Wine", false);

        create_test_wine(&db, "Wishlist Wine", true);

        let wishlist = get_wishlist_wines(&db).unwrap();

        assert_eq!(wishlist.len(), 1);

        assert_eq!(wishlist[0].name, "Wishlist Wine");

    }

    #[test]

    fn promote_wine_moves_to_cellar() {

        let db = test_db();

        let wine = create_test_wine(&db, "To Promote", true);

        assert!(promote_wine(&db, &wine.short_id).unwrap());

        let promoted = get_wine_by_short_id(&db, &wine.short_id).unwrap().unwrap();

        assert!(!promoted.wishlist);

        assert_eq!(get_wishlist_wines(&db).unwrap().len(), 0);

        assert_eq!(get_cellar_wines(&db).unwrap().len(), 1);

    }

    #[test]

    fn promote_cellar_wine_returns_false() {

        let db = test_db();

        let wine = create_test_wine(&db, "Already Cellar", false);

        assert!(!promote_wine(&db, &wine.short_id).unwrap());

    }

    #[test]

    fn update_wine_works() {

        let db = test_db();

        let wine = create_test_wine(&db, "Old Name", false);

        let updated = update_wine(

            &db, &wine.short_id, "New Name", "Italy", "Sangiovese", "Bold",

            4, 4, 4, 4, 4, 4, 4, 4, 4, "deep red",

        )

        .unwrap()

        .unwrap();

        assert_eq!(updated.name, "New Name");

        assert_eq!(updated.origin, "Italy");

        assert_eq!(updated.sweetness, 4);

        assert_eq!(updated.background, "deep red");

    }

    #[test]

    fn update_wishlist_wine_works() {

        let db = test_db();

        let wine = create_test_wine(&db, "Wish", true);

        let updated = update_wishlist_wine(

            &db, &wine.short_id, "Updated Wish", "Spain", "Tempranillo", "Try soon", "amber",

        )

        .unwrap()

        .unwrap();

        assert_eq!(updated.name, "Updated Wish");

        assert!(updated.wishlist);

    }

    #[test]

    fn update_wishlist_wine_on_cellar_wine_returns_none() {

        let db = test_db();

        let wine = create_test_wine(&db, "Cellar", false);

        let result = update_wishlist_wine(&db, &wine.short_id, "X", "X", "X", "X", "").unwrap();

        assert!(result.is_none());

    }

    #[test]

    fn update_wine_image_and_get() {

        let db = test_db();

        let wine = create_test_wine(&db, "Photo Wine", false);

        assert!(!wine.has_image);

        let img_data = vec![0xFF, 0xD8, 0xFF]; // fake JPEG header

        assert!(update_wine_image(&db, &wine.short_id, &img_data, "image/jpeg").unwrap());

        let (data, mime) = get_wine_image(&db, &wine.short_id).unwrap().unwrap();

        assert_eq!(data, img_data);

        assert_eq!(mime, "image/jpeg");

    }

    #[test]

    fn get_wine_image_no_image() {

        let db = test_db();

        let wine = create_test_wine(&db, "No Photo", false);

        assert!(get_wine_image(&db, &wine.short_id).unwrap().is_none());

    }

    #[test]

    fn delete_wine_works() {

        let db = test_db();

        let wine = create_test_wine(&db, "Delete Me", false);

        assert!(delete_wine(&db, &wine.short_id).unwrap());

        assert!(get_wine_by_short_id(&db, &wine.short_id).unwrap().is_none());

    }

    #[test]

    fn delete_nonexistent_wine() {

        let db = test_db();

        assert!(!delete_wine(&db, "nope").unwrap());

    }

    // ── Sessions ───────────────────────────────────────────────────────

    #[test]

    fn session_lifecycle() {

        let db = test_db();

        insert_session(&db, "tok", "2099-01-01 00:00:00").unwrap();

        assert!(get_session_expiry(&db, "tok").unwrap().is_some());

        delete_session(&db, "tok").unwrap();

        assert!(get_session_expiry(&db, "tok").unwrap().is_none());

    }

    #[test]

    fn prune_expired_sessions_works() {

        let db = test_db();

        insert_session(&db, "old", "2000-01-01 00:00:00").unwrap();

        insert_session(&db, "new", "2099-01-01 00:00:00").unwrap();

        prune_expired_sessions(&db).unwrap();

        assert!(get_session_expiry(&db, "old").unwrap().is_none());

        assert!(get_session_expiry(&db, "new").unwrap().is_some());

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn parse_opml_extracts_xml_urls() {

        let opml = r#"<?xml version="1.0" encoding="UTF-8"?>

<opml version="2.0">

  <body>

    <outline type="rss" text="Blog A" xmlUrl="https://a.com/feed" />

    <outline type="rss" text="Blog B" xmlUrl="https://b.com/rss" />

  </body>

</opml>"#;

        let urls = parse_opml(opml);

        assert_eq!(urls, vec!["https://a.com/feed", "https://b.com/rss"]);

    }

    #[test]

    fn parse_opml_empty_document() {

        let opml = r#"<?xml version="1.0"?><opml><body></body></opml>"#;

        assert!(parse_opml(opml).is_empty());

    }

    #[test]

    fn parse_opml_no_xml_url_attribute() {

        let opml = r#"<?xml version="1.0"?>

<opml><body>

  <outline type="rss" text="No URL" htmlUrl="https://example.com" />

</body></opml>"#;

        assert!(parse_opml(opml).is_empty());

    }

    #[test]

    fn parse_opml_nested_outlines() {

        let opml = r#"<?xml version="1.0"?>

<opml><body>

  <outline text="Category">

    <outline type="rss" text="Nested" xmlUrl="https://nested.com/feed" />

  </outline>

</body></opml>"#;

        let urls = parse_opml(opml);

        assert_eq!(urls, vec!["https://nested.com/feed"]);

    }

    #[test]

    fn parse_opml_skips_empty_url() {

        let opml = r#"<?xml version="1.0"?>

<opml><body>

  <outline type="rss" text="Empty" xmlUrl="" />

  <outline type="rss" text="Valid" xmlUrl="https://valid.com/feed" />

</body></opml>"#;

        let urls = parse_opml(opml);

        assert_eq!(urls, vec!["https://valid.com/feed"]);

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn escape_xml_ampersand() {

        assert_eq!(escape_xml("A&B"), "A&B");

    }

    #[test]

    fn escape_xml_less_than() {

        assert_eq!(escape_xml("a<b"), "a&lt;b");

    }

    #[test]

    fn escape_xml_greater_than() {

        assert_eq!(escape_xml("a>b"), "a>b");

    }

    #[test]

    fn escape_xml_quote() {

        assert_eq!(escape_xml(r#"a"b"#), "a"b");

    }

    #[test]

    fn escape_xml_apostrophe() {

        assert_eq!(escape_xml("a'b"), "a'b");

    }

    #[test]

    fn escape_xml_all_special() {

        assert_eq!(

            escape_xml(r#"<a href="x">&'test'</a>"#),

            "<a href="x">&'test'</a>"

        );

    }

    #[test]

    fn escape_xml_no_special_chars() {

        assert_eq!(escape_xml("hello world"), "hello world");

    }

    #[test]

    fn escape_xml_empty() {

        assert_eq!(escape_xml(""), "");

    }

    #[test]

    fn format_date_valid_timestamp() {

        // 2024-01-15 00:00:00 UTC

        assert_eq!(format_date(1705276800), "Jan 15, 2024");

    }

    #[test]

    fn format_date_zero() {

        assert_eq!(format_date(0), "Jan 1, 1970");

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    fn test_db() -> Db {

        let conn = Connection::open_in_memory().unwrap();

        conn.execute_batch(

            "CREATE TABLE IF NOT EXISTS notes (

                id         INTEGER PRIMARY KEY AUTOINCREMENT,

                short_id   TEXT NOT NULL UNIQUE,

                title      TEXT NOT NULL,

                content    TEXT NOT NULL,

                created_at TEXT NOT NULL DEFAULT (datetime('now')),

                updated_at TEXT NOT NULL DEFAULT (datetime('now'))

            );

            CREATE TABLE IF NOT EXISTS sessions (

                id         INTEGER PRIMARY KEY AUTOINCREMENT,

                token      TEXT NOT NULL UNIQUE,

                expires_at TEXT NOT NULL

            );",

        )

        .unwrap();

        Arc::new(Mutex::new(conn))

    }

    // ── Note CRUD ──────────────────────────────────────────────────────

    #[test]

    fn create_and_get_note() {

        let db = test_db();

        let note = create_note(&db, "My Note", "Some content").unwrap();

        assert_eq!(note.title, "My Note");

        assert_eq!(note.content, "Some content");

        let fetched = get_note_by_short_id(&db, &note.short_id).unwrap().unwrap();

        assert_eq!(fetched.title, "My Note");

    }

    #[test]

    fn get_note_not_found() {

        let db = test_db();

        assert!(get_note_by_short_id(&db, "nope").unwrap().is_none());

    }

    #[test]

    fn get_all_notes_ordered_desc() {

        let db = test_db();

        create_note(&db, "First", "a").unwrap();

        create_note(&db, "Second", "b").unwrap();

        let all = get_all_notes(&db).unwrap();

        assert_eq!(all.len(), 2);

        assert_eq!(all[0].title, "Second");

        assert_eq!(all[1].title, "First");

    }

    #[test]

    fn update_note() {

        let db = test_db();

        let note = create_note(&db, "Old", "old").unwrap();

        let updated = update_note_by_short_id(&db, &note.short_id, "New", "new")

            .unwrap()

            .unwrap();

        assert_eq!(updated.title, "New");

        assert_eq!(updated.content, "new");

    }

    #[test]

    fn update_nonexistent_note() {

        let db = test_db();

        assert!(update_note_by_short_id(&db, "nope", "x", "x").unwrap().is_none());

    }

    #[test]

    fn delete_note() {

        let db = test_db();

        let note = create_note(&db, "Del", "x").unwrap();

        assert!(delete_note_by_short_id(&db, &note.short_id).unwrap());

        assert!(get_note_by_short_id(&db, &note.short_id).unwrap().is_none());

    }

    #[test]

    fn delete_nonexistent_note() {

        let db = test_db();

        assert!(!delete_note_by_short_id(&db, "nope").unwrap());

    }

    // ── Sessions ───────────────────────────────────────────────────────

    #[test]

    fn session_lifecycle() {

        let db = test_db();

        insert_session(&db, "tok", "2099-01-01 00:00:00").unwrap();

        assert_eq!(

            get_session_expiry(&db, "tok").unwrap(),

            Some("2099-01-01 00:00:00".to_string())

        );

        delete_session(&db, "tok").unwrap();

        assert!(get_session_expiry(&db, "tok").unwrap().is_none());

    }

    #[test]

    fn prune_expired_sessions_works() {

        let db = test_db();

        insert_session(&db, "old", "2000-01-01 00:00:00").unwrap();

        insert_session(&db, "new", "2099-01-01 00:00:00").unwrap();

        prune_expired_sessions(&db).unwrap();

        assert!(get_session_expiry(&db, "old").unwrap().is_none());

        assert!(get_session_expiry(&db, "new").unwrap().is_some());

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    fn base() -> Url {

        Url::parse("https://example.com/page").unwrap()

    }

    // ── extract_favicon ────────────────────────────────────────────────

    #[test]

    fn favicon_from_rel_icon() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="icon" href="/favicon.png"></head></html>"#,

        );

        let result = extract_favicon(&doc, &base());

        assert_eq!(result, Some("https://example.com/favicon.png".to_string()));

    }

    #[test]

    fn favicon_from_shortcut_icon() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="shortcut icon" href="/icon.ico"></head></html>"#,

        );

        let result = extract_favicon(&doc, &base());

        assert_eq!(result, Some("https://example.com/icon.ico".to_string()));

    }

    #[test]

    fn favicon_from_apple_touch_icon() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="apple-touch-icon" href="/apple.png"></head></html>"#,

        );

        let result = extract_favicon(&doc, &base());

        assert_eq!(result, Some("https://example.com/apple.png".to_string()));

    }

    #[test]

    fn favicon_priority_icon_over_shortcut() {

        let doc = Html::parse_document(

            r#"<html><head>

                <link rel="icon" href="/first.png">

                <link rel="shortcut icon" href="/second.ico">

            </head></html>"#,

        );

        let result = extract_favicon(&doc, &base());

        assert_eq!(result, Some("https://example.com/first.png".to_string()));

    }

    #[test]

    fn favicon_fallback_to_favicon_ico() {

        let doc = Html::parse_document("<html><head></head></html>");

        let result = extract_favicon(&doc, &base());

        assert_eq!(result, Some("https://example.com/favicon.ico".to_string()));

    }

    #[test]

    fn favicon_resolves_relative_url() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="icon" href="assets/icon.png"></head></html>"#,

        );

        let result = extract_favicon(&doc, &base());

        assert_eq!(

            result,

            Some("https://example.com/assets/icon.png".to_string())

        );

    }

    // ── extract_link_tags ──────────────────────────────────────────────

    #[test]

    fn link_tags_extracts_multiple() {

        let doc = Html::parse_document(

            r#"<html><head>

                <link rel="stylesheet" href="/style.css">

                <link rel="canonical" href="https://example.com/">

            </head></html>"#,

        );

        let tags = extract_link_tags(&doc, &base());

        assert_eq!(tags.len(), 2);

        assert_eq!(tags[0].rel, "stylesheet");

        assert_eq!(tags[1].rel, "canonical");

    }

    #[test]

    fn link_tags_resolves_relative_href() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="stylesheet" href="css/main.css"></head></html>"#,

        );

        let tags = extract_link_tags(&doc, &base());

        assert_eq!(tags[0].href, "https://example.com/css/main.css");

    }

    #[test]

    fn link_tags_preserves_extra_attrs() {

        let doc = Html::parse_document(

            r#"<html><head><link rel="stylesheet" href="/s.css" type="text/css"></head></html>"#,

        );

        let tags = extract_link_tags(&doc, &base());

        assert!(tags[0].extra.contains("type=\"text/css\""));

    }

    #[test]

    fn link_tags_empty_head() {

        let doc = Html::parse_document("<html><head></head></html>");

        let tags = extract_link_tags(&doc, &base());

        assert!(tags.is_empty());

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn format_unix_epoch() {

        assert_eq!(format_unix_to_datetime(0, 0, 0, 0), "1970-01-01 00:00:00");

    }

    #[test]

    fn format_unix_known_date() {

        // 2024-01-15 = day 19737 since epoch

        assert_eq!(

            format_unix_to_datetime(19737, 12, 30, 45),

            "2024-01-15 12:30:45"

        );

    }

    #[test]

    fn format_unix_y2k() {

        // 2000-01-01 = day 10957

        assert_eq!(

            format_unix_to_datetime(10957, 0, 0, 0),

            "2000-01-01 00:00:00"

        );

    }

    #[test]

    fn format_unix_leap_day() {

        // 2024-02-29 = day 19782

        assert_eq!(

            format_unix_to_datetime(19782, 23, 59, 59),

            "2024-02-29 23:59:59"

        );

    }

    #[test]

    fn format_unix_end_of_year() {

        // 2023-12-31 = day 19722

        assert_eq!(

            format_unix_to_datetime(19722, 23, 59, 59),

            "2023-12-31 23:59:59"

        );

    }

    #[test]

    fn session_expiry_at_is_valid_format() {

        let expiry = session_expiry_at();

        // Should match YYYY-MM-DD HH:MM:SS

        assert_eq!(expiry.len(), 19);

        assert_eq!(&expiry[4..5], "-");

        assert_eq!(&expiry[7..8], "-");

        assert_eq!(&expiry[10..11], " ");

        assert_eq!(&expiry[13..14], ":");

        assert_eq!(&expiry[16..17], ":");

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    fn test_db() -> Db {

        let conn = Connection::open_in_memory().unwrap();

        conn.execute_batch("PRAGMA foreign_keys=ON;").unwrap();

        conn.execute_batch(

            "CREATE TABLE IF NOT EXISTS packages (

                id                INTEGER PRIMARY KEY AUTOINCREMENT,

                tracking_number   TEXT NOT NULL UNIQUE,

                label             TEXT,

                status            TEXT,

                status_category   TEXT,

                status_summary    TEXT,

                mail_class        TEXT,

                expected_delivery TEXT,

                last_refreshed_at TEXT,

                created_at        TEXT NOT NULL DEFAULT (datetime('now'))

            );

            CREATE TABLE IF NOT EXISTS tracking_events (

                id              INTEGER PRIMARY KEY AUTOINCREMENT,

                package_id      INTEGER NOT NULL REFERENCES packages(id) ON DELETE CASCADE,

                event_timestamp TEXT,

                event_type      TEXT,

                event_city      TEXT,

                event_state     TEXT,

                event_zip       TEXT,

                event_code      TEXT

            );

            CREATE TABLE IF NOT EXISTS sessions (

                id         INTEGER PRIMARY KEY AUTOINCREMENT,

                token      TEXT NOT NULL UNIQUE,

                expires_at TEXT NOT NULL

            );",

        )

        .unwrap();

        Arc::new(Mutex::new(conn))

    }

    // ── Package CRUD ───────────────────────────────────────────────────

    #[test]

    fn insert_and_list_packages() {

        let db = test_db();

        let id = insert_package(&db, "TRACK001", Some("My Package")).unwrap();

        assert!(id > 0);

        let packages = list_packages(&db).unwrap();

        assert_eq!(packages.len(), 1);

        assert_eq!(packages[0].tracking_number, "TRACK001");

        assert_eq!(packages[0].label.as_deref(), Some("My Package"));

    }

    #[test]

    fn insert_duplicate_tracking_number_fails() {

        let db = test_db();

        insert_package(&db, "TRACK001", None).unwrap();

        let result = insert_package(&db, "TRACK001", None);

        assert!(result.is_err());

    }

    #[test]

    fn get_package_found() {

        let db = test_db();

        let id = insert_package(&db, "TRACK001", None).unwrap();

        let pkg = get_package(&db, id).unwrap();

        assert!(pkg.is_some());

        assert_eq!(pkg.unwrap().tracking_number, "TRACK001");

    }

    #[test]

    fn get_package_not_found() {

        let db = test_db();

        let pkg = get_package(&db, 999).unwrap();

        assert!(pkg.is_none());

    }

    #[test]

    fn update_package_status_works() {

        let db = test_db();

        let id = insert_package(&db, "TRACK001", None).unwrap();

        update_package_status(

            &db,

            id,

            "Delivered",

            Some("Delivered"),

            Some("Package delivered"),

            Some("Priority"),

            Some("2024-01-20"),

            "2024-01-18 12:00:00",

        )

        .unwrap();

        let pkg = get_package(&db, id).unwrap().unwrap();

        assert_eq!(pkg.status.as_deref(), Some("Delivered"));

        assert_eq!(pkg.mail_class.as_deref(), Some("Priority"));

    }

    #[test]

    fn delete_package_removes_it() {

        let db = test_db();

        let id = insert_package(&db, "TRACK001", None).unwrap();

        delete_package(&db, id).unwrap();

        assert!(get_package(&db, id).unwrap().is_none());

    }

    // ── Tracking Events ────────────────────────────────────────────────

    #[test]

    fn insert_and_get_events() {

        let db = test_db();

        let pkg_id = insert_package(&db, "TRACK001", None).unwrap();

        insert_event(

            &db,

            pkg_id,

            Some("2024-01-15 10:00:00"),

            Some("Delivered"),

            Some("New York"),

            Some("NY"),

            Some("10001"),

            Some("01"),

        )

        .unwrap();

        insert_event(

            &db,

            pkg_id,

            Some("2024-01-14 08:00:00"),

            Some("In Transit"),

            Some("Chicago"),

            Some("IL"),

            None,

            None,

        )

        .unwrap();

        let events = get_events_for_package(&db, pkg_id).unwrap();

        assert_eq!(events.len(), 2);

        // Ordered by timestamp DESC

        assert_eq!(events[0].event_city.as_deref(), Some("New York"));

        assert_eq!(events[1].event_city.as_deref(), Some("Chicago"));

    }

    #[test]

    fn delete_events_for_package_clears_them() {

        let db = test_db();

        let pkg_id = insert_package(&db, "TRACK001", None).unwrap();

        insert_event(&db, pkg_id, None, Some("Shipped"), None, None, None, None).unwrap();

        delete_events_for_package(&db, pkg_id).unwrap();

        let events = get_events_for_package(&db, pkg_id).unwrap();

        assert!(events.is_empty());

    }

    #[test]

    fn delete_package_cascades_to_events() {

        let db = test_db();

        let pkg_id = insert_package(&db, "TRACK001", None).unwrap();

        insert_event(&db, pkg_id, None, Some("Shipped"), None, None, None, None).unwrap();

        delete_package(&db, pkg_id).unwrap();

        let events = get_events_for_package(&db, pkg_id).unwrap();

        assert!(events.is_empty());

    }

    // ── Sessions ───────────────────────────────────────────────────────

    #[test]

    fn session_crud_lifecycle() {

        let db = test_db();

        let token = "abc123";

        insert_session(&db, token, "2099-01-01 00:00:00").unwrap();

        let expiry = get_session_expiry(&db, token).unwrap();

        assert_eq!(expiry, Some("2099-01-01 00:00:00".to_string()));

        delete_session(&db, token).unwrap();

        let expiry = get_session_expiry(&db, token).unwrap();

        assert!(expiry.is_none());

    }

    #[test]

    fn get_session_expiry_missing_token() {

        let db = test_db();

        let expiry = get_session_expiry(&db, "nonexistent").unwrap();

        assert!(expiry.is_none());

    }

    #[test]

    fn prune_expired_sessions_removes_old() {

        let db = test_db();

        insert_session(&db, "expired", "2000-01-01 00:00:00").unwrap();

        insert_session(&db, "valid", "2099-01-01 00:00:00").unwrap();

        prune_expired_sessions(&db).unwrap();

        assert!(get_session_expiry(&db, "expired").unwrap().is_none());

        assert!(get_session_expiry(&db, "valid").unwrap().is_some());

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    fn test_db() -> Db {

        let conn = Connection::open_in_memory().unwrap();

        conn.execute_batch(

            "CREATE TABLE IF NOT EXISTS posts (

                id              INTEGER PRIMARY KEY AUTOINCREMENT,

                short_id        TEXT NOT NULL UNIQUE,

                title           TEXT NOT NULL,

                slug            TEXT NOT NULL UNIQUE,

                alias           TEXT,

                canonical_url   TEXT,

                published_date  TEXT,

                meta_description TEXT,

                meta_image      TEXT,

                lang            TEXT NOT NULL DEFAULT 'en',

                tags            TEXT,

                content         TEXT NOT NULL,

                status          TEXT NOT NULL DEFAULT 'draft',

                created_at      TEXT NOT NULL DEFAULT (datetime('now')),

                updated_at      TEXT NOT NULL DEFAULT (datetime('now'))

            );

            CREATE TABLE IF NOT EXISTS pages (

                id              INTEGER PRIMARY KEY AUTOINCREMENT,

                short_id        TEXT NOT NULL UNIQUE,

                title           TEXT NOT NULL,

                slug            TEXT NOT NULL UNIQUE,

                content         TEXT NOT NULL,

                is_published    INTEGER NOT NULL DEFAULT 0,

                nav_order       INTEGER NOT NULL DEFAULT 0,

                created_at      TEXT NOT NULL DEFAULT (datetime('now')),

                updated_at      TEXT NOT NULL DEFAULT (datetime('now'))

            );

            CREATE TABLE IF NOT EXISTS sessions (

                id              INTEGER PRIMARY KEY AUTOINCREMENT,

                token           TEXT NOT NULL UNIQUE,

                expires_at      TEXT NOT NULL

            );

            CREATE TABLE IF NOT EXISTS settings (

                key   TEXT PRIMARY KEY,

                value TEXT NOT NULL

            );

            CREATE TABLE IF NOT EXISTS files (

                id            INTEGER PRIMARY KEY AUTOINCREMENT,

                short_id      TEXT NOT NULL UNIQUE,

                filename      TEXT NOT NULL UNIQUE,

                original_name TEXT NOT NULL,

                content_type  TEXT NOT NULL DEFAULT 'application/octet-stream',

                size          INTEGER NOT NULL,

                created_at    TEXT NOT NULL DEFAULT (datetime('now'))

            );",

        )

        .unwrap();

        Arc::new(Mutex::new(conn))

    }

    // ── Post CRUD ──────────────────────────────────────────────────────

    #[test]

    fn create_and_get_post() {

        let db = test_db();

        let post = create_post(

            &db, "Hello World", "hello-world", "# Hello", "draft",

            None, None, None, None, None, "en", None,

        )

        .unwrap();

        assert_eq!(post.title, "Hello World");

        assert_eq!(post.slug, "hello-world");

        assert_eq!(post.status, "draft");

        let fetched = get_post_by_short_id(&db, &post.short_id).unwrap().unwrap();

        assert_eq!(fetched.title, "Hello World");

    }

    #[test]

    fn get_post_by_slug_works() {

        let db = test_db();

        create_post(

            &db, "Test", "test-slug", "content", "published",

            None, None, Some("2024-01-01"), None, None, "en", None,

        )

        .unwrap();

        let post = get_post_by_slug(&db, "test-slug").unwrap().unwrap();

        assert_eq!(post.title, "Test");

    }

    #[test]

    fn duplicate_slug_fails() {

        let db = test_db();

        create_post(&db, "A", "same-slug", "a", "draft", None, None, None, None, None, "en", None).unwrap();

        let result = create_post(&db, "B", "same-slug", "b", "draft", None, None, None, None, None, "en", None);

        assert!(result.is_err());

    }

    #[test]

    fn get_all_posts_ordered_desc() {

        let db = test_db();

        create_post(&db, "First", "first", "a", "draft", None, None, None, None, None, "en", None).unwrap();

        create_post(&db, "Second", "second", "b", "draft", None, None, None, None, None, "en", None).unwrap();

        let all = get_all_posts(&db).unwrap();

        assert_eq!(all.len(), 2);

        assert_eq!(all[0].title, "Second");

        assert_eq!(all[1].title, "First");

    }

    #[test]

    fn get_published_posts_filters() {

        let db = test_db();

        create_post(&db, "Draft", "draft", "a", "draft", None, None, None, None, None, "en", None).unwrap();

        create_post(&db, "Published", "pub", "b", "published", None, None, Some("2024-01-01"), None, None, "en", None).unwrap();

        let published = get_published_posts(&db).unwrap();

        assert_eq!(published.len(), 1);

        assert_eq!(published[0].title, "Published");

    }

    #[test]

    fn delete_post_works() {

        let db = test_db();

        let post = create_post(&db, "Del", "del", "x", "draft", None, None, None, None, None, "en", None).unwrap();

        assert!(delete_post(&db, &post.short_id).unwrap());

        assert!(get_post_by_short_id(&db, &post.short_id).unwrap().is_none());

    }

    #[test]

    fn toggle_post_status_draft_to_published() {

        let db = test_db();

        let post = create_post(&db, "Toggle", "toggle", "x", "draft", None, None, None, None, None, "en", None).unwrap();

        let new_status = toggle_post_status(&db, &post.short_id).unwrap().unwrap();

        assert_eq!(new_status, "published");

        let updated = get_post_by_short_id(&db, &post.short_id).unwrap().unwrap();

        assert_eq!(updated.status, "published");

        assert!(updated.published_date.is_some());

    }

    #[test]

    fn toggle_post_status_published_to_draft() {

        let db = test_db();

        let post = create_post(&db, "Toggle", "toggle", "x", "published", None, None, Some("2024-01-01"), None, None, "en", None).unwrap();

        let new_status = toggle_post_status(&db, &post.short_id).unwrap().unwrap();

        assert_eq!(new_status, "draft");

    }

    #[test]

    fn find_alias_redirect_found() {

        let db = test_db();

        create_post(&db, "Aliased", "aliased-post", "x", "published", Some("old-url"), None, Some("2024-01-01"), None, None, "en", None).unwrap();

        let redirect = find_alias_redirect(&db, "old-url").unwrap();

        assert_eq!(redirect, Some("/posts/aliased-post".to_string()));

    }

    #[test]

    fn find_alias_redirect_not_found() {

        let db = test_db();

        assert!(find_alias_redirect(&db, "nonexistent").unwrap().is_none());

    }

    #[test]

    fn find_alias_redirect_only_published() {

        let db = test_db();

        create_post(&db, "Draft Alias", "draft-alias", "x", "draft", Some("my-alias"), None, None, None, None, "en", None).unwrap();

        assert!(find_alias_redirect(&db, "my-alias").unwrap().is_none());

    }

    // ── Page CRUD ──────────────────────────────────────────────────────

    #[test]

    fn create_and_get_page() {

        let db = test_db();

        let page = create_page(&db, "About", "about", "About content", true, 1).unwrap();

        assert_eq!(page.title, "About");

        assert!(page.is_published);

        let fetched = get_page_by_short_id(&db, &page.short_id).unwrap().unwrap();

        assert_eq!(fetched.slug, "about");

    }

    #[test]

    fn get_page_by_slug_works() {

        let db = test_db();

        create_page(&db, "Contact", "contact", "Email us", false, 2).unwrap();

        let page = get_page_by_slug(&db, "contact").unwrap().unwrap();

        assert_eq!(page.title, "Contact");

    }

    #[test]

    fn get_published_pages_filters() {

        let db = test_db();

        create_page(&db, "Pub", "pub", "x", true, 1).unwrap();

        create_page(&db, "Draft", "draft", "x", false, 2).unwrap();

        let published = get_published_pages(&db).unwrap();

        assert_eq!(published.len(), 1);

        assert_eq!(published[0].title, "Pub");

    }

    #[test]

    fn update_page_works() {

        let db = test_db();

        let page = create_page(&db, "Old", "old", "old content", false, 0).unwrap();

        let updated = update_page(&db, &page.short_id, "New", "new", "new content", true, 5)

            .unwrap()

            .unwrap();

        assert_eq!(updated.title, "New");

        assert!(updated.is_published);

        assert_eq!(updated.nav_order, 5);

    }

    #[test]

    fn delete_page_works() {

        let db = test_db();

        let page = create_page(&db, "Del", "del", "x", false, 0).unwrap();

        assert!(delete_page(&db, &page.short_id).unwrap());

        assert!(get_page_by_short_id(&db, &page.short_id).unwrap().is_none());

    }

    // ── Settings ───────────────────────────────────────────────────────

    #[test]

    fn settings_get_set() {

        let db = test_db();

        set_setting(&db, "blog_title", "My Blog").unwrap();

        let val = get_setting(&db, "blog_title").unwrap();

        assert_eq!(val, Some("My Blog".to_string()));

    }

    #[test]

    fn settings_upsert() {

        let db = test_db();

        set_setting(&db, "key", "first").unwrap();

        set_setting(&db, "key", "second").unwrap();

        assert_eq!(get_setting(&db, "key").unwrap(), Some("second".to_string()));

    }

    #[test]

    fn settings_missing_key() {

        let db = test_db();

        assert!(get_setting(&db, "nonexistent").unwrap().is_none());

    }

    #[test]

    fn get_all_settings_works() {

        let db = test_db();

        set_setting(&db, "a", "1").unwrap();

        set_setting(&db, "b", "2").unwrap();

        let all = get_all_settings(&db).unwrap();

        assert_eq!(all.len(), 2);

        assert_eq!(all[0], ("a".to_string(), "1".to_string()));

    }

    // ── File CRUD ──────────────────────────────────────────────────────

    #[test]

    fn create_and_get_files() {

        let db = test_db();

        let file = create_file(&db, "abc123.jpg", "photo.jpg", "image/jpeg", 1024).unwrap();

        assert_eq!(file.filename, "abc123.jpg");

        assert_eq!(file.original_name, "photo.jpg");

        assert_eq!(file.size, 1024);

        let all = get_all_files(&db).unwrap();

        assert_eq!(all.len(), 1);

    }

    #[test]

    fn delete_file_returns_deleted() {

        let db = test_db();

        let file = create_file(&db, "f.txt", "f.txt", "text/plain", 10).unwrap();

        let deleted = delete_file(&db, &file.short_id).unwrap();

        assert!(deleted.is_some());

        assert_eq!(deleted.unwrap().filename, "f.txt");

        assert!(get_all_files(&db).unwrap().is_empty());

    }

    #[test]

    fn delete_file_not_found() {

        let db = test_db();

        assert!(delete_file(&db, "nonexistent").unwrap().is_none());

    }

    // ── Sessions ───────────────────────────────────────────────────────

    #[test]

    fn session_lifecycle() {

        let db = test_db();

        insert_session(&db, "tok", "2099-12-31 23:59:59").unwrap();

        assert_eq!(

            get_session_expiry(&db, "tok").unwrap(),

            Some("2099-12-31 23:59:59".to_string())

        );

        delete_session(&db, "tok").unwrap();

        assert!(get_session_expiry(&db, "tok").unwrap().is_none());

    }

    #[test]

    fn prune_expired_sessions_works() {

        let db = test_db();

        insert_session(&db, "old", "2000-01-01 00:00:00").unwrap();

        insert_session(&db, "new", "2099-01-01 00:00:00").unwrap();

        prune_expired_sessions(&db).unwrap();

        assert!(get_session_expiry(&db, "old").unwrap().is_none());

        assert!(get_session_expiry(&db, "new").unwrap().is_some());

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    // ── build_download_filename ────────────────────────────────────────

    #[test]

    fn filename_with_extension() {

        assert_eq!(build_download_filename("photo.png", "jpg"), "photo_compressed.jpg");

    }

    #[test]

    fn filename_without_extension() {

        assert_eq!(build_download_filename("photo", "jpg"), "photo_compressed.jpg");

    }

    #[test]

    fn filename_empty_string() {

        assert_eq!(build_download_filename("", "jpg"), "compressed_compressed.jpg");

    }

    #[test]

    fn filename_multiple_dots() {

        assert_eq!(

            build_download_filename("my.cool.photo.png", "jpg"),

            "my.cool.photo_compressed.jpg"

        );

    }

    // ── strip_gps_from_exif ────────────────────────────────────────────

    #[test]

    fn strip_gps_too_short_returns_unchanged() {

        let data = vec![0u8; 4];

        assert_eq!(strip_gps_from_exif(&data), data);

    }

    #[test]

    fn strip_gps_no_tiff_header_returns_unchanged() {

        let data = vec![0u8; 32];

        assert_eq!(strip_gps_from_exif(&data), data);

    }

    #[test]

    fn strip_gps_little_endian_zeroes_gps_ifd() {

        // Build minimal TIFF (little-endian) with one IFD entry: GPS tag 0x8825

        let mut data = Vec::new();

        // TIFF header: "II" + magic 42 + offset to IFD0 (8)

        data.extend_from_slice(b"II");

        data.extend_from_slice(&42u16.to_le_bytes());

        data.extend_from_slice(&8u32.to_le_bytes()); // IFD0 at offset 8

        // IFD0 at offset 8: 1 entry

        data.extend_from_slice(&1u16.to_le_bytes());

        // IFD entry: tag=0x8825 (GPS), type=LONG(4), count=1, value=offset to GPS IFD

        let gps_ifd_offset: u32 = 22; // right after this IFD entry + next IFD pointer

        data.extend_from_slice(&0x8825u16.to_le_bytes());

        data.extend_from_slice(&4u16.to_le_bytes()); // type LONG

        data.extend_from_slice(&1u32.to_le_bytes()); // count

        data.extend_from_slice(&gps_ifd_offset.to_le_bytes()); // GPS IFD offset

        // Next IFD pointer (none)

        // We need padding to get to offset 22

        // Current size = 8 + 2 + 12 = 22, perfect

        // GPS IFD at offset 22: entry count = 5 (nonzero, should be zeroed)

        data.extend_from_slice(&5u16.to_le_bytes());

        // Some dummy GPS entries

        data.extend_from_slice(&[0u8; 24]);

        let result = strip_gps_from_exif(&data);

        // GPS IFD entry count at offset 22 should now be 0

        let gps_count = u16::from_le_bytes([result[22], result[23]]);

        assert_eq!(gps_count, 0);

    }

    #[test]

    fn strip_gps_big_endian_zeroes_gps_ifd() {

        let mut data = Vec::new();

        // TIFF header: "MM" + magic 42 + offset to IFD0 (8)

        data.extend_from_slice(b"MM");

        data.extend_from_slice(&42u16.to_be_bytes());

        data.extend_from_slice(&8u32.to_be_bytes());

        // IFD0: 1 entry

        data.extend_from_slice(&1u16.to_be_bytes());

        // GPS tag entry pointing to GPS IFD at offset 22

        data.extend_from_slice(&0x8825u16.to_be_bytes());

        data.extend_from_slice(&4u16.to_be_bytes());

        data.extend_from_slice(&1u32.to_be_bytes());

        data.extend_from_slice(&22u32.to_be_bytes());

        // GPS IFD at offset 22

        data.extend_from_slice(&3u16.to_be_bytes()); // 3 entries

        data.extend_from_slice(&[0u8; 24]);

        let result = strip_gps_from_exif(&data);

        let gps_count = u16::from_be_bytes([result[22], result[23]]);

        assert_eq!(gps_count, 0);

    }

    #[test]

    fn strip_gps_no_gps_tag_unchanged() {

        let mut data = Vec::new();