hypermail/

html.rs

use std::path::PathBuf;

use crate::config::{Config, DELETE_LEAVES_STUBS, DELETE_LEAVES_TEXT};
use crate::date::{get_date_str, secs_to_iso};
use crate::error::Result;
use crate::file_utils::{message_name, message_path as utils_message_path, message_url_str};
use crate::headers::decode_mime_words;
use crate::i18n::I18n;
use crate::message::EmailInfo;
use crate::string_utils::{obfuscate_email_address, spamify};
use crate::structs::EmailStore;
use crate::templates::{
    default_article_template, default_footer_template, default_header_template, get_header_cookies,
    set_cookie, substitute_cookies, substitute_printfile, PrintfileData,
};
use crate::txt2html::escape_html;

/// Renders a complete HTML page for a single email message.
pub fn print_article(email: &EmailInfo, store: &EmailStore, config: &Config) -> Result<String> {
    // If delete_level < DELETE_LEAVES_TEXT, show "Deleted message" stub
    // If delete_level >= DELETE_LEAVES_TEXT, show the actual message content
    if email.is_deleted != 0 && config.delete_level < DELETE_LEAVES_TEXT {
        return print_deleted_article(email, store, config);
    }

    let article_html = generate_article_email(email, store, config)?;

    render_message_page(email, config, &article_html)
}

fn load_template_or_default(path: Option<&str>, default: &str) -> String {
    path.and_then(|p| std::fs::read_to_string(p).ok())
        .unwrap_or_else(|| default.to_string())
}

/// Render a complete message HTML page, using external templates (mhtmlheader/mhtmlfooter)
/// with printfile-style %x substitution when configured, or the default internal templates.
fn render_message_page(email: &EmailInfo, config: &Config, article_html: &str) -> Result<String> {
    if config.mhtmlheader.is_some() || config.mhtmlfooter.is_some() {
        // External templates: use original hypermail printfile-style %x substitution.
        let header_tpl = config
            .mhtmlheader
            .as_deref()
            .and_then(|p| std::fs::read_to_string(p).ok())
            .unwrap_or_default();
        let footer_tpl = config
            .mhtmlfooter
            .as_deref()
            .and_then(|p| std::fs::read_to_string(p).ok())
            .unwrap_or_default();

        let date_str = if email.date > 0 {
            secs_to_iso(email.date)
        } else {
            String::new()
        };
        let display_date_str = if email.date > 0 {
            get_date_str(
                email.date,
                config.dateformat.as_deref(),
                config.gmtime,
                config.eurodate,
                config.isodate,
                &config.language,
            )
        } else {
            String::new()
        };
        let filename = message_url_str(email, config);
        let i18n = I18n::new(&config.language);
        let raw_subject = email.subject.as_deref().unwrap_or(i18n.get("no subject"));
        let decoded_subject = format_subject_for_index(raw_subject, config);
        let decoded_name = decode_mime_words(email.name.as_deref().unwrap_or(""));
        let data = PrintfileData {
            label: config.label.as_deref().unwrap_or(""),
            subject: &decoded_subject,
            dir: config.dir.as_deref().unwrap_or("."),
            name: Some(decoded_name.as_str()),
            email: email.email_addr.as_deref(),
            msgid: email.msgid.as_deref(),
            charset: email.charset.as_deref(),
            date: if date_str.is_empty() {
                None
            } else {
                Some(date_str.as_str())
            },
            display_date: if display_date_str.is_empty() {
                None
            } else {
                Some(display_date_str.as_str())
            },
            filename: Some(filename.as_str()),
            archives: config.archives.as_deref(),
            about: config.about.as_deref(),
            mailto: config.mailto.as_deref(),
            language: &config.language,
            rel_path_to_top: "",
        };

        let header_html = substitute_printfile(&header_tpl, &data);
        let footer_html = substitute_printfile(&footer_tpl, &data);
        let generator = if config.showgenerator {
            let i18n = I18n::new(&config.language);
            let gen_text = crate::txt2html::escape_html(i18n.get("Generated by"));
            format!(
                "\n<p class=\"hm-generator\">{} <a href=\"https://hypermail-rs.github.io\">hypermail-rs</a></p>\n",
                gen_text
            )
        } else {
            String::new()
        };
        Ok(format!("{}{}{}{}", header_html, article_html, footer_html, generator))
    } else {
        // Internal default templates: use %COOKIE_NAME% substitution.
        let i18n = I18n::new(&config.language);
        let subject_raw = email.subject.as_deref().unwrap_or(i18n.get("no subject"));
        let subject = &format_subject_for_index(subject_raw, config);
        let mut cookies = get_header_cookies(config, subject);
        set_cookie(&mut cookies, "ARTICLE", article_html);

        if email.is_deleted != 0 && email.is_deleted & 2 != 0 {
            set_cookie(&mut cookies, "DELETED_NOTE", i18n.get("Expired message"));
            set_cookie(&mut cookies, "DELETED_HTML", "");
        } else if email.is_deleted != 0 {
            set_cookie(&mut cookies, "DELETED_NOTE", i18n.get("Deleted message"));
            set_cookie(&mut cookies, "DELETED_HTML", "");
        }

        let header_template = load_template_or_default(None, default_header_template());
        let footer_template = load_template_or_default(None, default_footer_template());
        let article_template = default_article_template();

        let header_html = substitute_cookies(&header_template, &cookies);
        let article_content = substitute_cookies(article_template, &cookies);
        let mut nav_cookies = cookies.clone();
        set_cookie(&mut nav_cookies, "NAVIGATION", "");
        let footer_html = substitute_cookies(&footer_template, &nav_cookies);
        Ok(format!("{}{}{}", header_html, article_content, footer_html))
    }
}

fn print_deleted_article(
    email: &EmailInfo,
    _store: &EmailStore,
    config: &Config,
) -> Result<String> {
    let note = if email.is_deleted & 2 != 0 {
        let i18n = I18n::new(&config.language);
        i18n.get("Expired message").to_string()
    } else {
        let i18n = I18n::new(&config.language);
        i18n.get("Deleted message").to_string()
    };
    let mut article_html = String::new();
    article_html.push_str(&format!("<p class=\"hm-deleted\">{}</p>\n", note));

    render_message_page(email, config, &article_html)
}

fn generate_article_email(
    email: &EmailInfo,
    store: &EmailStore,
    config: &Config,
) -> Result<String> {
    let i18n = I18n::new(&config.language);
    let mut html = String::new();

    html.push_str(&format!(
        "<article id=\"{}{}\">\n",
        escape_html(&config.fragment_prefix),
        email.msgnum
    ));

    if config.showheaders {
        html.push_str("<table class=\"hm-msg-header\" aria-label=\"Message headers\">\n<tbody>\n");

        html.push_str(&format!(
            "<tr><th class=\"hm-hdrlabel\" scope=\"row\">{}</th><td class=\"hm-hdrdata\">{}</td></tr>\n",
            escape_html(i18n.get("Author")),
            format_author(email, config)
        ));

        html.push_str(&format!(
            "<tr><th class=\"hm-hdrlabel\" scope=\"row\">{}</th><td class=\"hm-hdrdata\">{}</td></tr>\n",
            escape_html(i18n.get("Date")),
            format_date(email, config)
        ));

        let subject = email.subject.as_deref().unwrap_or(i18n.get("no subject"));
        html.push_str(&format!(
            "<tr><th class=\"hm-hdrlabel\" scope=\"row\">{}</th><td class=\"hm-hdrdata\">{}</td></tr>\n",
            escape_html(i18n.get("Subject")),
            format_subject_text(subject, config)
        ));

        // Message-ID is kept in HTML comments but not displayed in the visible header table
        // This reduces clutter while preserving the ID for debugging/threading purposes

        html.push_str("</tbody>\n</table>\n");
    }

    if config.showreplies {
        if let Some(reply_html) = format_reply_links(email, store, config) {
            html.push_str(&reply_html);
        }
    }

    html.push_str("<hr class=\"hm-msg-sep\">\n");

    // Only show [Deleted]/[Expired] note if we're not showing the body content
    // If delete_level >= DELETE_LEAVES_TEXT, we show the body, so no need for the note
    if email.is_deleted != 0
        && config.delete_level >= DELETE_LEAVES_STUBS
        && config.delete_level < DELETE_LEAVES_TEXT
    {
        let note = if email.is_deleted & 2 != 0 {
            i18n.get("[Expired]")
        } else {
            i18n.get("[Deleted]")
        };
        html.push_str(&format!("<p class=\"hm-deleted\">{}</p>\n", note));
        if email.bodylist.bodies.is_empty() {
            html.push_str("</article>\n");
            return Ok(html);
        }
    }

    let body_html = format_body(&email.bodylist, config);
    html.push_str(&body_html);
    html.push_str("</article>\n");

    Ok(html)
}

fn format_author(email: &EmailInfo, config: &Config) -> String {
    let display_name = decode_mime_words(email.name.as_deref().unwrap_or(""));
    let display_addr = email.email_addr.as_deref().unwrap_or("unknown");

    let obfuscated_addr = if config.email_address_obfuscation {
        obfuscate_email_address(display_addr)
    } else {
        escape_html(display_addr)
    };

    let final_addr = spamify(
        &obfuscated_addr,
        &config.antispam_at,
        config.antispamdomain.as_deref(),
        config.spamprotect,
        config.spamprotect_id,
    );

    let escaped_name = escape_html(&display_name);

    let mailto = if let Some(ref hmail) = config.hmail {
        hmail.replace("$TO", display_addr)
    } else {
        format!("mailto:{}", display_addr)
    };

    if display_name.is_empty() {
        format!("<a href=\"{}\">{}</a>", escape_html(&mailto), final_addr)
    } else {
        format!(
            "{} &lt;<a href=\"{}\">{}</a>&gt;",
            escaped_name,
            escape_html(&mailto),
            final_addr
        )
    }
}

fn format_date(email: &EmailInfo, config: &Config) -> String {
    let timestamp = email.date;
    let date_str = get_date_str(
        timestamp,
        config.dateformat.as_deref(),
        config.gmtime,
        config.eurodate,
        config.isodate,
        &config.language,
    );
    let iso_str = secs_to_iso(timestamp);
    format!("<time datetime=\"{}\">{}</time>", escape_html(&iso_str), escape_html(&date_str))
}

/// Decode and strip the list tag from a subject, for use in both message and index pages.
pub fn format_subject_for_index(subject: &str, config: &Config) -> String {
    let decoded = decode_mime_words(subject);
    if let Some(ref strip) = config.stripsubject {
        let trimmed = decoded.strip_prefix(strip.as_str()).map(|s| s.trim());
        match trimmed {
            Some(s) if !s.is_empty() => s.to_string(),
            _ => decoded,
        }
    } else {
        decoded
    }
}

fn format_subject_text(subject: &str, config: &Config) -> String {
    escape_html(&format_subject_for_index(subject, config))
}

fn format_reply_links(email: &EmailInfo, store: &EmailStore, config: &Config) -> Option<String> {
    let i18n = I18n::new(&config.language);
    if store.replylist.is_empty() {
        return None;
    }

    let mut reply_indices: Vec<usize> = Vec::new();
    for reply in &store.replylist {
        if reply.from_msgnum == email.msgnum {
            if let Some(idx) = store.find_by_msgnum(reply.msgnum) {
                reply_indices.push(idx);
            }
        }
    }

    if reply_indices.is_empty() {
        return None;
    }

    let mut html = String::from("<ul class=\"hm-reply-list\">\n");
    for &idx in &reply_indices {
        let rep = &store.emails[idx];
        let filename = crate::file_utils::message_url_str(rep, config);
        let subject = rep.subject.as_deref().unwrap_or(i18n.get("no subject"));
        let author = decode_mime_words(rep.name.as_deref().unwrap_or(i18n.get("unknown author")));
        html.push_str(&format!(
            "  <li><a href=\"{}\">{} by {}</a></li>\n",
            escape_html(&filename),
            format_subject_text(subject, config),
            escape_html(&author)
        ));
    }
    html.push_str("</ul>\n");
    Some(html)
}

/// True if `line` is markup produced by our converters (trusted class names only).
/// Rejects arbitrary `<div onclick=…>` / `<hr onload=…>` that would otherwise
/// pass through because they start with `<div` / `<hr`.
fn is_trusted_body_markup(line: &str) -> bool {
    let s = line.trim_start();
    if s.starts_with("<hr class=\"hm-sig\">") || s.starts_with("<hr class=\"hm-sig\"") {
        return true;
    }
    if !s.starts_with("<div class=\"") {
        return false;
    }
    // Known classes emitted by txt2html / conv_showhtml
    const TRUSTED: &[&str] = &[
        "<div class=\"hm-blank\"",
        "<div class=\"hm-pg\"",
        "<div class=\"hm-sig-text\"",
        "<div class=\"hm-quote-1\"",
        "<div class=\"hm-quote-2\"",
        "<div class=\"hm-quote-3\"",
        "<div class=\"hm-quote-4\"",
        "<div class=\"hm-quote-5\"",
        "<div class=\"hm-quote-6\"",
        "<div class=\"hm-quote-7\"",
        "<div class=\"hm-quote-8\"",
        "<div class=\"hm-quote-9\"",
    ];
    TRUSTED.iter().any(|p| s.starts_with(p))
}

fn format_body(body_chain: &crate::message::BodyChain, config: &Config) -> String {
    let i18n = I18n::new(&config.language);
    let mut html = String::new();
    let mut in_attachment = false;

    // Coalescing state: consecutive lines with the same opening tag (e.g. all
    // `<div class="hm-pg">…</div>`) are merged into ONE block, joined by `\n`.
    // With `white-space: pre-wrap` in CSS, this renders identically to N
    // separate divs but eliminates the block-level vertical gap between every
    // single line — the body reads as one flowing paragraph instead of a
    // double-spaced list.
    let mut run_open: Option<String> = None;
    let mut run_inner = String::new();

    let flush_run = |html: &mut String, run_open: &mut Option<String>, run_inner: &mut String| {
        if let Some(open) = run_open.take() {
            html.push_str(&open);
            html.push_str(run_inner);
            html.push_str("</div>\n");
            run_inner.clear();
        }
    };

    // Returns the opening `<div …>` tag of a coalesce-eligible line, plus the
    // inner content. A line is eligible iff it begins with `<div ` and ends
    // with `</div>\n` (or `</div>`). Anything else (e.g. `<hr …>`,
    // `<div …><img …></div>` we still merge if same class) breaks the run.
    fn split_div_line(s: &str) -> Option<(&str, &str)> {
        let s = s.strip_suffix('\n').unwrap_or(s);
        let s = s.strip_suffix("</div>")?;
        if !s.starts_with("<div ") {
            return None;
        }
        let close = s.find('>')?;
        let open = &s[..=close];
        let inner = &s[close + 1..];
        Some((open, inner))
    }

    for body in &body_chain.bodies {
        if body.header {
            continue;
        }

        if body.attached {
            flush_run(&mut html, &mut run_open, &mut run_inner);
            if !in_attachment {
                html.push_str(&format!(
                    "<details class=\"hm-attachment\"><summary>{}</summary>\n",
                    i18n.get("Attachment")
                ));
                in_attachment = true;
            }
            // Strip the [Attachment: name] wrapper and show the filename cleanly.
            let filename = body
                .line
                .strip_prefix("[Attachment: ")
                .and_then(|s| s.strip_suffix(']'))
                .unwrap_or(&body.line);
            html.push_str(&format!("<p>{}</p>\n", escape_html(filename)));
        } else {
            if in_attachment {
                html.push_str("</details>\n");
                in_attachment = false;
            }
            // Only pass through converter-emitted markup (hm-* classes). showhtml>=2
            // may leave raw HTML; that still goes through the allowlist or is escaped.
            if is_trusted_body_markup(&body.line) {
                // Blank-line marker: produce a paragraph gap *within* the
                // current run. Combined with the trailing `\n` already on the
                // previous line, this gives `pre-wrap` a real empty line.
                if body.line.starts_with("<div class=\"hm-blank\"") {
                    if run_open.is_some() {
                        run_inner.push('\n');
                    }
                    continue;
                }
                if let Some((open, inner)) = split_div_line(&body.line) {
                    match &run_open {
                        Some(cur_open) if cur_open == open => {
                            // Same class as current run — append with newline.
                            run_inner.push('\n');
                            run_inner.push_str(inner);
                        },
                        _ => {
                            flush_run(&mut html, &mut run_open, &mut run_inner);
                            run_open = Some(open.to_string());
                            run_inner.push_str(inner);
                        },
                    }
                } else {
                    // Non-coalescable trusted line (e.g. <hr class="hm-sig">).
                    flush_run(&mut html, &mut run_open, &mut run_inner);
                    html.push_str(&body.line);
                }
            } else {
                flush_run(&mut html, &mut run_open, &mut run_inner);
                html.push_str(&escape_html(&body.line));
            }
        }
    }

    flush_run(&mut html, &mut run_open, &mut run_inner);

    if in_attachment {
        html.push_str("</details>\n");
    }

    html
}

#[cfg(test)]
fn generate_navigation(email: &EmailInfo, config: &Config) -> Result<String> {
    let i18n = I18n::new(&config.language);
    let mut nav = String::from("<nav class=\"hm-nav\" aria-label=\"Message navigation\">\n");

    let filename = crate::file_utils::message_url_str(email, config);
    nav.push_str(&format!("  <a href=\"{}\">{}</a>\n", filename, i18n.get("Article")));

    if config.show_msg_links > 0 {
        nav.push_str(&format!(
            "  <a href=\"index.{}\">{}</a>\n",
            config.htmlsuffix,
            i18n.get("Index")
        ));
    }

    nav.push_str("</nav>\n");
    Ok(nav)
}

/// Returns the HTML filename for a given email message.
pub fn get_message_filename(email: &EmailInfo, config: &Config) -> String {
    format!("{}.{}", message_name(email, config), config.htmlsuffix)
}

/// Returns the full filesystem path for a message's HTML file.
pub fn get_message_path(email: &EmailInfo, config: &Config) -> PathBuf {
    utils_message_path(email, config)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::Config;
    use crate::message::{Body, BodyChain, EmailInfo};

    fn make_test_email() -> EmailInfo {
        EmailInfo {
            msgnum: 42,
            date: 1615824000,
            from_date_str: Some("Mon, 15 Mar 2021 12:00:00 +0000".to_string()),
            date_str: Some("Mon, 15 Mar 2021 12:00:00 +0000".to_string()),
            name: Some("Alice".to_string()),
            email_addr: Some("alice@example.com".to_string()),
            subject: Some("Test Message".to_string()),
            msgid: Some("<abc123@example.com>".to_string()),
            charset: Some("utf-8".to_string()),
            inreplyto: Some("<parent@example.com>".to_string()),
            bodylist: BodyChain {
                bodies: vec![Body {
                    line: "Hello World".to_string(),
                    html: false,
                    header: false,
                    parsed_header: false,
                    attached: false,
                    demimed: false,
                    msgnum: 0,
                }],
            },
            ..Default::default()
        }
    }

    #[test]
    fn test_format_author() {
        let email = make_test_email();
        let config = Config::default();
        let result = format_author(&email, &config);
        assert!(result.contains("Alice"));
        assert!(result.contains("alice@example.com"));
    }

    #[test]
    fn test_format_subject() {
        let config = Config::default();
        let result = format_subject_text("Test Message", &config);
        assert_eq!(result, "Test Message");
    }

    #[test]
    fn test_format_subject_stripsubject() {
        let mut config = Config::default();
        config.stripsubject = Some("[mylist] ".to_string());

        assert_eq!(format_subject_text("[mylist] Hello", &config), "Hello");
        assert_eq!(format_subject_text("[mylist]  Hello", &config), "Hello"); // double space trimmed
        assert_eq!(format_subject_text("No prefix here", &config), "No prefix here");
    }

    #[test]
    fn test_format_subject_stripsubject_no_trailing_space() {
        // stripsubject without trailing space (e.g. "JotD..."):
        // "JotD... The joke" → strip "JotD..." → " The joke" → trim → "The joke"
        let mut config = Config::default();
        config.stripsubject = Some("JotD...".to_string());

        assert_eq!(format_subject_text("JotD... The joke", &config), "The joke");
        assert_eq!(format_subject_text("JotD...  Spaces  ", &config), "Spaces"); // trim both ends
        assert_eq!(format_subject_text("JotD...", &config), "JotD..."); // empty after strip → keep original
        assert_eq!(format_subject_text("Other subject", &config), "Other subject");
    }

    #[test]
    fn test_get_message_filename() {
        let mut config = Config::default();
        let mut email = make_test_email();
        assert_eq!(get_message_filename(&email, &config), "0042.html");
        config.nonsequential = true;
        email.from_date = 1615824000;
        let name = get_message_filename(&email, &config);
        assert_eq!(name.len(), 21); // 16 hex + ".html"
    }

    #[test]
    fn test_format_date() {
        let email = make_test_email();
        let config = Config::default();
        let result = format_date(&email, &config);
        assert!(!result.is_empty());
    }

    #[test]
    fn test_deleted_article_stub() {
        let mut email = make_test_email();
        email.is_deleted = 1;
        let config = Config::default();
        let result = print_article(&email, &crate::structs::EmailStore::new(), &config).unwrap();
        assert!(result.contains("Deleted") || result.contains("deleted"));
    }

    #[test]
    fn test_format_body_escapes_raw_text() {
        let mut chain = BodyChain { bodies: Vec::new() };
        chain.bodies.push(Body {
            line: "<script>alert('xss')</script>".to_string(),
            html: false,
            header: false,
            parsed_header: false,
            attached: false,
            demimed: false,
            msgnum: 1,
        });
        let config = Config::default();
        let result = format_body(&chain, &config);
        assert!(result.contains("&lt;script&gt;"));
        assert!(!result.contains("<script>"));
    }

    #[test]
    fn test_format_body_passes_div_through() {
        let mut chain = BodyChain { bodies: Vec::new() };
        chain.bodies.push(Body {
            line: "<div class=\"hm-pg\">safe</div>\n".to_string(),
            html: false,
            header: false,
            parsed_header: false,
            attached: false,
            demimed: false,
            msgnum: 1,
        });
        let config = Config::default();
        let result = format_body(&chain, &config);
        assert!(result.contains("<div class=\"hm-pg\">safe</div>"));
    }

    #[test]
    fn test_message_id_spam_protected() {
        let email = make_test_email();
        let mut config = Config::default();
        config.spamprotect_id = true;
        config.antispam_at = " at ".to_string();
        let store = crate::structs::EmailStore::new();
        let result = print_article(&email, &store, &config).unwrap();
        assert!(result.contains(" at "));
        assert!(!result.contains("abc123@example.com"));
    }

    #[test]
    fn test_nonsequential_navigation_link() {
        let email = make_test_email();
        let mut config = Config::default();
        config.nonsequential = true;
        let result = generate_navigation(&email, &config).unwrap();
        // Link should be hex hash based, not msgnum
        assert!(!result.contains("0042.html"));
        assert!(result.contains(".html"));
    }

    #[test]
    fn test_format_author_no_double_mailto() {
        let email = make_test_email();
        let config = Config::default();
        let result = format_author(&email, &config);
        // href should contain exactly one mailto: prefix, not mailto:mailto:
        assert!(result.contains("href=\"mailto:"), "should have mailto: link");
        assert!(!result.contains("mailto:mailto:"), "should NOT have double mailto: prefix");
    }

    #[test]
    fn test_format_author_with_hmail_no_double_mailto() {
        let email = make_test_email();
        let mut config = Config::default();
        config.hmail = Some("mailto:$TO?subject=test".to_string());
        let result = format_author(&email, &config);
        assert!(
            !result.contains("mailto:mailto:"),
            "hmail substitution should NOT produce double mailto:"
        );
    }

    #[test]
    fn test_article_uses_id_not_a_name() {
        let email = make_test_email();
        let store = crate::structs::EmailStore::new();
        let config = Config::default();
        let result = print_article(&email, &store, &config).unwrap();
        // Should use <article id="..."> not <a name="...">
        assert!(result.contains("<article id=\""), "should use <article id=>");
        assert!(!result.contains("<a name=\""), "should NOT use deprecated <a name=>");
    }

    #[test]
    fn test_subject_xss_escaped_in_title() {
        let mut email = make_test_email();
        email.subject = Some("</title><script>alert(1)</script>".to_string());
        let store = crate::structs::EmailStore::new();
        let config = Config::default();
        let result = print_article(&email, &store, &config).unwrap();
        assert!(!result.contains("<script>alert(1)</script>"), "raw script in subject");
        assert!(result.contains("&lt;script&gt;") || result.contains("&lt;/title&gt;"));
    }

    #[test]
    fn test_inline_image_xss_in_body_not_emitted() {
        let mut email = make_test_email();
        email.bodylist = BodyChain {
            bodies: vec![Body {
                line: r#"[INLINE_IMAGE:image/png:x" onerror="alert(1)]"#.to_string(),
                html: false,
                header: false,
                parsed_header: false,
                attached: false,
                demimed: false,
                msgnum: 42,
            }],
        };
        let store = crate::structs::EmailStore::new();
        let config = Config::default();
        // process like main does
        let mut store_email = email.clone();
        crate::txt2html::conv_showhtml(&mut store_email.bodylist, &config);
        let result = print_article(&store_email, &store, &config).unwrap();
        assert!(
            !result.contains("<img"),
            "malicious INLINE_IMAGE must not become img: {}",
            result
        );
        assert!(
            !result.contains(r#"onerror=""#),
            "must not create onerror attribute: {}",
            result
        );
    }
}