Heroku To AWS

scripts/test_validate_heroku_migration_report.py

"""Tests for the heroku-to-aws migration-report.html validator."""

from __future__ import annotations

import json
import subprocess  # nosec B404 — test-only, list args, no shell, committed script path
import sys
import tempfile
from pathlib import Path

SCRIPT = Path(__file__).resolve().parent / "validate-heroku-migration-report.py"


def run(html: str, migration_dir: Path | None = None, mode: str | None = None) -> tuple[int, str]:
    with tempfile.TemporaryDirectory() as tmp:
        report = Path(tmp) / "migration-report.html"
        report.write_text(html, encoding="utf-8")
        cmd = [sys.executable, str(SCRIPT), str(report)]
        if migration_dir is not None:
            cmd += ["--migration-dir", str(migration_dir)]
        if mode is not None:
            cmd += ["--mode", mode]
        result = subprocess.run(cmd, capture_output=True, text=True)  # nosec B603
        return result.returncode, result.stdout + result.stderr


# A minimal but complete, compliant Heroku report.
GOOD = """<!DOCTYPE html>
<html lang="en">
<body>
<div class="report">
  <section id="decision-summary"><p class="verdict-headline">Go, with conditions</p></section>
  <section id="exec-costs"><table><thead><tr><th scope="col">Tier</th></tr></thead><tbody><tr><td>Balanced</td></tr></tbody></table></section>
  <section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>
  <section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>
  <footer>Generated by Heroku to AWS Migration Advisor — draft for review; verify figures before executive sign-off.</footer>
</div>
</body>
</html>
"""


def _rec_dir(tmp: str) -> Path:
    d = Path(tmp)
    (d / "estimation-infra.json").write_text(
        json.dumps({"recommendation": {"outcome": "go_conditional"}}), encoding="utf-8"
    )
    return d


def test_good_report_passes() -> None:
    code, out = run(GOOD)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_missing_cost_optimization_fails() -> None:
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        "",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_missing_draft_footer_fails() -> None:
    html = GOOD.replace("draft for review; verify figures before executive sign-off.", "")
    code, out = run(html)
    assert code == 1, out
    assert "draft for review" in out.lower()


def test_badge_verdict_pill_fails() -> None:
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<span class="badge-verdict-go">Go</span>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "badge-verdict" in out.lower() or "verdict-headline" in out.lower()


def test_th_without_scope_fails() -> None:
    html = GOOD.replace('<th scope="col">Tier</th>', "<th>Tier</th>")
    code, out = run(html)
    assert code == 1, out
    assert "scope" in out.lower()


def test_missing_html_lang_fails() -> None:
    html = GOOD.replace('<html lang="en">', "<html>")
    code, out = run(html)
    assert code == 1, out
    assert "lang" in out.lower()


def test_verdict_headline_required_when_recommendation_outcome_present() -> None:
    # No verdict-headline in decision-summary; recommendation.outcome is declared → FAIL.
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        "<p>Go, with conditions</p>",
    )
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(html, migration_dir=_rec_dir(tmp))
    assert code == 1, out
    assert "verdict-headline" in out.lower()


def test_verdict_headline_not_required_without_recommendation() -> None:
    # Same HTML, but no estimation-infra.json recommendation → the headline
    # requirement does not fire (the plain-text verdict is allowed).
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        "<p>Go, with conditions</p>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_would_flip_required_when_artifact_has_it() -> None:
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<p class="verdict-headline">Go, with conditions</p>'
        "<h3>What would flip this</h3><ul><li>A published rate above the Heroku bill.</li></ul>",
    )
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "estimation-infra.json").write_text(
            json.dumps(
                {
                    "recommendation": {
                        "outcome": "go_conditional",
                        "would_flip_if": ["A published rate above the Heroku bill."],
                    }
                }
            ),
            encoding="utf-8",
        )
        missing, out = run(GOOD, migration_dir=d)
        present, ok = run(html, migration_dir=d)
    assert missing == 1, out
    assert "would_flip" in out
    assert present == 0, ok


VERDICT = '<p class="verdict-headline">Go, with conditions</p>'
FLIPS = ["A published rate above the Heroku bill.", "Dyno count doubles before cutover."]
FLIP_ITEMS = "".join(f"<li>{flip}</li>" for flip in FLIPS)


def _run_with_flips(html: str) -> tuple[int, str]:
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "estimation-infra.json").write_text(
            json.dumps(
                {"recommendation": {"outcome": "go_conditional", "would_flip_if": FLIPS}}
            ),
            encoding="utf-8",
        )
        return run(html, migration_dir=d)


def test_would_flip_heading_accepts_equivalent_visible_spellings() -> None:
    # Line breaks, &nbsp; entities and inline markup inside the heading all read
    # as "What would flip this" to the reader and must match.
    for heading in (
        "<h3>What would flip this</h3>",
        "<h3>What\nwould\nflip this</h3>",
        "<h3>What&nbsp;would&nbsp;flip this</h3>",
        "<h3>What <em>would</em> flip this</h3>",
    ):
        code, out = _run_with_flips(GOOD.replace(VERDICT, VERDICT + heading + f"<ul>{FLIP_ITEMS}</ul>"))
        assert code == 0, (heading, out)


def test_would_flip_heading_in_comment_or_template_fails() -> None:
    for inert in (
        "<!-- What would flip this -->",
        "<template><h3>What would flip this</h3></template>",
    ):
        code, out = _run_with_flips(GOOD.replace(VERDICT, VERDICT + inert + f"<ul>{FLIP_ITEMS}</ul>"))
        assert code == 1, (inert, out)
        assert "would_flip" in out


def test_would_flip_empty_list_fails() -> None:
    code, out = _run_with_flips(
        GOOD.replace(VERDICT, VERDICT + "<h3>What would flip this</h3><ul></ul>")
    )
    assert code == 1, out
    assert "0 of 2" in out, out


def test_would_flip_partial_list_fails() -> None:
    code, out = _run_with_flips(
        GOOD.replace(VERDICT, VERDICT + f"<h3>What would flip this</h3><ul><li>{FLIPS[0]}</li></ul>")
    )
    assert code == 1, out
    assert "1 of 2" in out and "Dyno count" in out, out


def _run_with_custom_flips(html: str, flips: list[str]) -> tuple[int, str]:
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "estimation-infra.json").write_text(
            json.dumps(
                {"recommendation": {"outcome": "go_conditional", "would_flip_if": flips}}
            ),
            encoding="utf-8",
        )
        return run(html, migration_dir=d)


def test_would_flip_shared_suffix_cannot_cross_satisfy_items() -> None:
    flips = [
        "Database changes require specialist evidence",
        "Compute changes require specialist evidence",
    ]
    html = GOOD.replace(
        VERDICT,
        VERDICT
        + "<h3>What would flip this</h3>"
        + "<ul><li>Database changes require specialist evidence</li></ul>",
    )
    code, out = _run_with_custom_flips(html, flips)
    assert code == 1, out
    assert "1 of 2" in out and "Compute" in out, out


def test_would_flip_shared_suffix_complete_items_pass() -> None:
    flips = [
        "Database changes require specialist evidence",
        "Compute changes require specialist evidence",
    ]
    html = GOOD.replace(
        VERDICT,
        VERDICT
        + "<h3>What would flip this</h3>"
        + "<ul>"
        "<li>Database changes require specialist evidence</li>"
        "<li>Compute changes require specialist evidence</li>"
        "</ul>",
    )
    code, out = _run_with_custom_flips(html, flips)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_would_flip_complete_list_passes() -> None:
    code, out = _run_with_flips(
        GOOD.replace(VERDICT, VERDICT + f"<h3>What would flip this</h3><ul>{FLIP_ITEMS}</ul>")
    )
    assert code == 0, out
    assert "REPORT_OK" in out


def test_would_flip_lead_in_paragraph_before_list_passes() -> None:
    # A one-sentence lead-in between the heading and the <ul> is legitimate
    # output; the items below it are rendered and must be found (regression for
    # the matcher stopping at the first non-item run and reporting "0 of N").
    code, out = _run_with_flips(
        GOOD.replace(
            VERDICT,
            VERDICT
            + "<h3>What would flip this</h3>"
            + '<p class="muted">Any of these would change the verdict:</p>'
            + f"<ul>{FLIP_ITEMS}</ul>",
        )
    )
    assert code == 0, out
    assert "REPORT_OK" in out


def test_would_flip_lead_in_paragraph_with_empty_list_fails() -> None:
    code, out = _run_with_flips(
        GOOD.replace(
            VERDICT,
            VERDICT
            + "<h3>What would flip this</h3>"
            + '<p class="muted">Any of these would change the verdict:</p><ul></ul>',
        )
    )
    assert code == 1, out
    assert "0 of 2" in out, out


def test_would_flip_inline_label_item_passes() -> None:
    # generate-report.md only asks for a "short unordered list"; the
    # heroku-decision-gate fixtures render the label inside the first item
    # (`<li>What would flip this: …</li>`) with no separate heading. That item's
    # remainder plus its siblings are the list.
    code, out = _run_with_flips(
        GOOD.replace(
            VERDICT,
            VERDICT + f"<ul><li>What would flip this: {FLIPS[0]}</li><li>{FLIPS[1]}</li></ul>",
        )
    )
    assert code == 0, out
    assert "REPORT_OK" in out


def test_would_flip_inline_label_partial_list_fails() -> None:
    code, out = _run_with_flips(
        GOOD.replace(VERDICT, VERDICT + f"<ul><li>What would flip this: {FLIPS[0]}</li></ul>")
    )
    assert code == 1, out
    assert "1 of 2" in out and "Dyno count" in out, out


def test_decision_gate_fixtures_render_their_flip_condition() -> None:
    # The checked-in decision fixtures declare would_flip_if and render it in the
    # inline-label shape; they must keep passing --mode decision so the fixture
    # asserters (check_expected_decide*.py) exercise the flip check for real.
    fixtures = SCRIPT.parents[3] / "fixtures" / "heroku-decision-gate"
    for name in ("after-decide-complete", "retained-execution-pack"):
        run_dir = fixtures / name
        estimate = json.loads((run_dir / "estimation-infra.json").read_text(encoding="utf-8"))
        assert estimate["recommendation"]["would_flip_if"], name
        result = subprocess.run(  # nosec B603
            [
                sys.executable,
                str(SCRIPT),
                str(run_dir / "decision-report.html"),
                "--mode",
                "decision",
                "--migration-dir",
                str(run_dir),
            ],
            capture_output=True,
            text=True,
        )
        assert result.returncode == 0, (name, result.stdout + result.stderr)


def test_what_if_columns_required_when_section_present() -> None:
    thin = GOOD.replace(
        '<section id="next-steps">',
        '<section id="what-if-scenarios"><table><thead><tr>'
        '<th scope="col">Scenario</th><th scope="col">Monthly</th>'
        "</tr></thead><tbody><tr><td>Baseline</td><td>$1</td></tr></tbody></table></section>"
        '<section id="next-steps">',
    )
    full = GOOD.replace(
        '<section id="next-steps">',
        '<section id="what-if-scenarios"><table><thead><tr>'
        '<th scope="col">Scenario</th><th scope="col">Region</th><th scope="col">HA</th>'
        '<th scope="col">Compute</th><th scope="col">Arch</th>'
        '<th scope="col">Complexity</th></tr></thead>'
        "<tbody><tr><td>Baseline</td><td>us-east-1</td><td>Multi-AZ</td>"
        "<td>Fargate</td><td>mixed</td><td>Large</td></tr></tbody></table></section>"
        '<section id="next-steps">',
    )
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "scenarios").mkdir()
        (d / "scenarios" / "index.json").write_text(
            json.dumps({"scenarios": [{"id": "a"}, {"id": "b"}]}), encoding="utf-8"
        )
        bad, bad_out = run(thin, migration_dir=d)
        good, good_out = run(full, migration_dir=d)
    assert bad == 1, bad_out
    assert "Region" in bad_out
    assert good == 0, good_out


def test_what_if_required_when_two_scenarios() -> None:
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "scenarios").mkdir()
        (d / "scenarios" / "index.json").write_text(
            json.dumps({"scenarios": [{"id": "a"}, {"id": "b"}]}), encoding="utf-8"
        )
        code, out = run(GOOD, migration_dir=d)
    assert code == 1, out
    assert "what-if-scenarios" in out


def test_good_report_with_recommendation_passes() -> None:
    # Happy path WITH a declared outcome: the verdict-headline is present, so the
    # recommendation-gated requirement is satisfied and the report passes.
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(GOOD, migration_dir=_rec_dir(tmp))
    assert code == 0, out
    assert "REPORT_OK" in out


def test_empty_cost_optimization_fails() -> None:
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out and "empty" in out.lower()


def test_no_eligible_sentence_with_entity_hyphens_passes() -> None:
    # Regression (09-22 P2): the no-commitment sentence written with entity-escaped
    # hyphens (`1&#45;year`) renders as the exact required text — must satisfy the
    # content check (decoded rendered text, not a raw literal match).
    html = GOOD.replace(
        "No 1-year/3-year commitment product applies to this architecture.",
        "No 1&#45;year/3&#45;year commitment product applies to this architecture.",
    )
    code, out = run(html)
    assert code == 0, out


def test_no_eligible_sentence_with_nbsp_passes() -> None:
    # Regression (09-22 P2): `&nbsp;` between words decodes to whitespace; the
    # sentence must still be recognized after whitespace normalization.
    html = GOOD.replace(
        "No 1-year/3-year commitment product applies to this architecture.",
        "No&nbsp;1-year/3-year&nbsp;commitment product applies to this architecture.",
    )
    code, out = run(html)
    assert code == 0, out


def test_no_eligible_sentence_only_in_comment_fails() -> None:
    # Regression (09-22 P2): the sentence present ONLY inside an HTML comment is
    # not rendered — must NOT satisfy the content requirement.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><!-- No 1-year/3-year commitment product applies to this architecture. --><p>See optimization notes.</p></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_no_eligible_sentence_only_in_template_fails() -> None:
    # Regression (09-22 P2): the sentence present ONLY inside an inert <template>
    # is not rendered — must NOT satisfy the content requirement.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><template><p>No 1-year/3-year commitment product applies to this architecture.</p></template><p>See optimization notes.</p></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_heading_only_cost_optimization_fails() -> None:
    # A heading alone (no opportunity table, no no-eligible-commitment sentence)
    # must not satisfy the content requirement.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><h2>Cost Optimization Opportunities</h2></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_table_headers_only_cost_optimization_fails() -> None:
    # A table with column headers but an empty <tbody> — no actual opportunity
    # rows — must not satisfy the content requirement either.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><thead><tr>'
        '<th scope="col">Opportunity</th><th scope="col">Savings</th>'
        "</tr></thead><tbody></tbody></table></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_cost_optimization_with_real_opportunity_row_passes() -> None:
    # Control: an actual populated row in the tbody is real content and passes.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><thead><tr>'
        '<th scope="col">Opportunity</th></tr></thead><tbody><tr>'
        "<td>1yr Compute Savings Plan: ~25%</td></tr></tbody></table></section>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_empty_tbody_with_credits_disclaimer_fails() -> None:
    # Regression: an empty <tbody> plus the credits disclaimer prose that normally
    # accompanies a populated table must NOT satisfy the content check on its own —
    # the disclaimer is explanatory text, not an opportunity row or the explicit
    # no-eligible-commitment sentence.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><thead><tr>'
        '<th scope="col">Optimization</th></tr></thead><tbody></tbody></table>'
        "<p>Activate credits don't cover RI/Savings Plan upfront costs — they apply "
        "only to the ongoing discounted hourly rate.</p></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_th_only_row_in_tbody_does_not_count_as_opportunity_row() -> None:
    # A <tbody> row made only of <th> cells (no <td>) must not count as a
    # populated opportunity row.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><thead><tr>'
        '<th scope="col">Opportunity</th></tr></thead><tbody><tr>'
        '<th scope="row">Totals</th></tr></tbody></table></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_nbsp_only_opportunity_cell_fails() -> None:
    # Regression: a <td> whose only content is a non-breaking-space entity is
    # visually blank. Raw-source matching sees "&nbsp;" as non-empty literal
    # text; a parser that decodes character references first correctly treats
    # it as blank.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tbody><tr>'
        "<td>&nbsp;</td></tr></tbody></table></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_numeric_charref_only_opportunity_cell_fails() -> None:
    # Same as above but with the numeric character reference form (&#160;)
    # rather than the named entity.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tbody><tr>'
        "<td>&#160;</td></tr></tbody></table></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_commented_out_opportunity_row_fails() -> None:
    # Regression: a real opportunity row that is commented out in the HTML
    # source must not count. A regex scanning raw source can match inside an
    # HTML comment; a parser naturally routes comment text away from
    # handle_data.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tbody>'
        "<!-- <tr><td>RDS Reserved Instance</td></tr> --></tbody></table></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_opportunity_row_without_explicit_tbody_passes() -> None:
    # Regression: <table><tr><td>...</td></tr></table> with no <tbody> tag at
    # all is valid HTML (an implicit tbody is inferred) and a real opportunity
    # row inside it must still count as content.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tr>'
        "<td>RDS Reserved Instance</td></tr></table></section>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_opportunity_row_with_omitted_td_end_tag_passes() -> None:
    # Regression: the HTML Standard permits a <td> end tag to be omitted
    # immediately before the parent </tr>. A compact, perfectly valid table
    # with no </td> at all must still register its real content — the old
    # parser only finalized a cell on an EXPLICIT handle_endtag("td"), so this
    # exact shape silently registered as empty and failed a valid report.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tr>'
        "<td>RDS Reserved Instance</tr></table></section>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_opportunity_row_with_sibling_omitted_td_end_tags_passes() -> None:
    # Two sibling cells in the same row, both with omitted end tags — the
    # second cell's start tag implicitly closes the first. The real
    # opportunity text in the second cell must still be found.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tr>'
        "<td>Opportunity<td>RDS Reserved Instance</tr></table></section>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_opportunity_row_with_omitted_td_end_tag_blank_cell_still_fails() -> None:
    # Control: an omitted end tag on a genuinely BLANK cell must not
    # accidentally start passing just because the end tag is optional —
    # only real, nonblank text should ever satisfy this check.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tr><td></tr></table></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_th_scope_with_spaces_around_equals_passes() -> None:
    # scope = "col" (spaces around =) is valid HTML and must be accepted —
    # a literal `scope="col"` regex would wrongly reject it.
    html = GOOD.replace('<th scope="col">Tier</th>', '<th scope = "col">Tier</th>')
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_th_scope_unquoted_passes() -> None:
    # scope=col (unquoted attribute value) is valid HTML and must be accepted.
    html = GOOD.replace('<th scope="col">Tier</th>', "<th scope=col>Tier</th>")
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_th_scope_single_quoted_passes() -> None:
    html = GOOD.replace('<th scope="col">Tier</th>', "<th scope='col'>Tier</th>")
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_html_lang_with_spaces_around_equals_passes() -> None:
    html = GOOD.replace('<html lang="en">', '<html lang = "en">')
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_figure_aria_label_unquoted_passes() -> None:
    html = GOOD.replace(
        "</div>",
        "<figure aria-label=Costs><figcaption>Costs</figcaption></figure></div>",
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_figure_without_aria_label_fails() -> None:
    html = GOOD.replace("</div>", "<figure><figcaption>Costs</figcaption></figure></div>")
    code, out = run(html)
    assert code == 1, out
    assert "aria-label" in out.lower()


def test_figure_with_aria_label_and_figcaption_passes() -> None:
    html = GOOD.replace(
        "</div>",
        '<figure aria-label="Cost breakdown"><figcaption>Costs</figcaption></figure></div>',
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_verdict_headline_with_spaces_around_equals_passes() -> None:
    # class = "verdict-headline" (spaces around =) is valid HTML and must be
    # accepted when recommendation.outcome is declared.
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<p class = "verdict-headline">Go, with conditions</p>',
    )
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(html, migration_dir=_rec_dir(tmp))
    assert code == 0, out
    assert "REPORT_OK" in out


def test_verdict_headline_unquoted_passes() -> None:
    # class=verdict-headline (unquoted, single token) is valid HTML and must be
    # accepted when recommendation.outcome is declared.
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        "<p class=verdict-headline>Go, with conditions</p>",
    )
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(html, migration_dir=_rec_dir(tmp))
    assert code == 0, out
    assert "REPORT_OK" in out


def test_badge_verdict_pill_with_spaces_around_equals_fails() -> None:
    # class = "badge-verdict-go" (spaces around =) is valid, equivalent HTML and
    # must still be caught by the badge ban — it must not bypass the check by
    # using different (but legal) attribute formatting.
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<p class="verdict-headline">Go, with conditions</p>'
        '<span class = "badge-verdict-go">Go</span>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "badge-verdict" in out.lower()


def test_badge_verdict_pill_unquoted_fails() -> None:
    # class=badge-verdict-go (unquoted) must also be caught — regression for the
    # gap where a badge alongside a normal headline returned REPORT_OK because
    # the literal `class="..."` regex didn't match unquoted attribute syntax.
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<p class="verdict-headline">Go, with conditions</p>'
        "<span class=badge-verdict-go>Go</span>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "badge-verdict" in out.lower()


def test_figure_without_figcaption_fails() -> None:
    """A <figure> with aria-label but no <figcaption> fails (symmetric to the aria-label case)."""
    html = GOOD.replace("</div>", '<figure aria-label="Costs">chart</figure></div>')
    code, out = run(html)
    assert code == 1, out
    assert "figcaption" in out.lower()


def test_validator_is_packaged_inside_the_skill_directory() -> None:
    """The validator must live under skills/heroku-to-aws/ so a standalone
    `npx skills add --skill heroku-to-aws` install (which copies only this
    skill's own directory tree, not the plugin's top-level scripts/) still
    carries it. Regression for the packaging gap where the validator lived at
    the plugin root and Generate's `$PLUGIN_ROOT/scripts/...` invocation had
    nothing to resolve against in a skill-only install."""
    assert SCRIPT.is_file()
    assert SCRIPT.parent.name == "scripts"
    assert SCRIPT.parent.parent.name == "heroku-to-aws"
    assert SCRIPT.parent.parent.parent.name == "skills"


# --- Inert/hidden-content negative controls (sweep: close the class across every
# rendered-content check, not one parser per review round). Inert = never rendered
# by the browser: <script>, <style>, <template>. ---


def test_inert_only_opportunity_table_fails() -> None:
    """A whole opportunity table nested in a <template> is never rendered, so it
    must not satisfy the cost-optimization content requirement."""
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><template><table><tr>'
        "<td>RDS Reserved Instance</td></tr></table></template></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_opportunity_cell_only_inert_content_fails() -> None:
    """A visible row whose only cell content is an inert <template>/<script>
    subtree renders nothing, so it is not a populated opportunity row."""
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<section id="cost-optimization"><table><tr>'
        '<td><script type="application/json">{"x":1}</script></td></tr>'
        "<tr><td><template>RDS Reserved Instance</template></td></tr>"
        "</table></section>",
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_verdict_headline_only_in_template_fails() -> None:
    """A verdict-headline that exists only inside an inert <template> renders no
    verdict, so a declared recommendation.outcome must still fail the check."""
    html = GOOD.replace(
        '<p class="verdict-headline">Go, with conditions</p>',
        '<template><p class="verdict-headline">Go, with conditions</p></template>',
    )
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(html, migration_dir=_rec_dir(tmp))
    assert code == 1, out
    assert "verdict-headline" in out.lower()


def test_th_inside_template_not_audited_for_scope() -> None:
    """A <th> inside an inert <template> is never rendered, so the accessibility
    scan must not demand scope="col"/"row" on it (no false-positive). The visible
    exec-costs table keeps its valid scope, so the report still passes."""
    html = GOOD.replace(
        "</table></section>",
        "</table>"
        "<template><table><tr><th>Hidden header, no scope</th></tr></table></template>"
        "</section>",
        1,
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_verdict_headline_only_in_hidden_element_or_ancestor_fails() -> None:
    for replacement in (
        '<p hidden class="verdict-headline">Go, with conditions</p>',
        '<div hidden><p class="verdict-headline">Go, with conditions</p></div>',
    ):
        html = GOOD.replace(
            '<p class="verdict-headline">Go, with conditions</p>', replacement
        )
        with tempfile.TemporaryDirectory() as tmp:
            code, out = run(html, migration_dir=_rec_dir(tmp))
        assert code == 1, (replacement, out)
        assert "verdict-headline" in out.lower()


def test_would_flip_populated_list_only_in_hidden_element_or_ancestor_fails() -> None:
    for replacement in (
        '<h3>What would flip this</h3><ul hidden>'
        f'{FLIP_ITEMS}</ul>',
        f'<div hidden><h3>What would flip this</h3><ul>{FLIP_ITEMS}</ul></div>',
    ):
        code, out = _run_with_flips(GOOD.replace(VERDICT, VERDICT + replacement))
        assert code == 1, (replacement, out)
        assert "would_flip" in out


# --- Section-parser regressions (09-22 P2): section identity/counts come from the
# stdlib parser, so comments and inert (script/style/template) subtrees never satisfy
# a section gate, real quoted/unquoted/spaced ids pass, and data-id is not the id. ---


def test_template_wrapped_section_does_not_satisfy_requirement() -> None:
    # A required section wrapped entirely in an inert <template> is never rendered,
    # so it must not count as present.
    html = GOOD.replace(
        '<section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section>',
        '<template><section id="cost-optimization"><p>No 1-year/3-year commitment product applies to this architecture.</p></section></template>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "cost-optimization" in out


def test_commented_section_does_not_satisfy_requirement() -> None:
    # A section that exists only inside an HTML comment is not rendered.
    html = GOOD.replace(
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>',
        "<!-- <section id=\"next-steps\"><ol><li>x</li></ol></section> -->",
    )
    code, out = run(html)
    assert code == 1, out
    assert "next-steps" in out


def test_data_id_is_not_treated_as_section_id() -> None:
    # data-id must not be read as the section id.
    html = GOOD.replace(
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>',
        '<section data-id="next-steps"><ol><li>x</li></ol></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "next-steps" in out


def test_unquoted_and_spaced_section_ids_are_accepted() -> None:
    # Equivalent HTML in different valid spellings must count the same.
    html = GOOD.replace('<section id="next-steps">', "<section id = next-steps>")
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_commented_duplicate_does_not_inflate_count() -> None:
    # A commented copy of a required section must not trigger a duplicate error.
    html = GOOD.replace(
        '<section id="exec-costs"><table><thead><tr><th scope="col">Tier</th></tr></thead><tbody><tr><td>Balanced</td></tr></tbody></table></section>',
        '<section id="exec-costs"><table><thead><tr><th scope="col">Tier</th></tr></thead><tbody><tr><td>Balanced</td></tr></tbody></table></section>'
        '<!-- <section id="exec-costs">dup</section> -->',
    )
    code, out = run(html)
    assert code == 0, out
    assert "REPORT_OK" in out


def test_verdict_headline_only_in_template_fails_via_section_parser() -> None:
    # A decision-summary whose entire content (verdict headline) lives inside a
    # <template> renders no verdict; with a declared recommendation.outcome it must fail.
    html = GOOD.replace(
        '<section id="decision-summary"><p class="verdict-headline">Go, with conditions</p></section>',
        '<template><section id="decision-summary"><p class="verdict-headline">Go, with conditions</p></section></template>'
        '<section id="decision-summary"><p>Go, with conditions</p></section>',
    )
    with tempfile.TemporaryDirectory() as tmp:
        code, out = run(html, migration_dir=_rec_dir(tmp))
    assert code == 1, out
    assert "verdict-headline" in out.lower()


# --- Decision-mode coverage (--mode decision), ported to the co-located suite. ---

DECISION_GOOD = """<!DOCTYPE html>
<html lang="en">
<body>
<div class="report">
  <section id="decision-summary"><p class="verdict-headline">Go, with conditions</p></section>
  <section id="exec-costs"><table><thead><tr><th scope="col">Tier</th></tr></thead><tbody><tr><td>Balanced</td></tr></tbody></table></section>
  <section id="decision-cta"><p>Ready to execute? Re-run with Execute.</p></section>
  <footer>Generated by Heroku to AWS Migration Advisor — draft for review; verify figures before executive sign-off.</footer>
</div>
</body>
</html>
"""


def test_decision_mode_minimal_passes() -> None:
    code, out = run(DECISION_GOOD, mode="decision")
    assert code == 0, out
    assert "REPORT_OK" in out


def test_decision_mode_requires_decision_cta_not_next_steps() -> None:
    # decision mode requires decision-cta; a next-steps terminal is the wrong mode.
    html = DECISION_GOOD.replace("decision-cta", "next-steps")
    code, out = run(html, mode="decision")
    assert code == 1, out
    assert "decision-cta" in out


def test_full_mode_must_not_carry_decision_cta() -> None:
    # The other mode's terminal section must not appear in full mode.
    html = GOOD.replace(
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>',
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>'
        '<section id="decision-cta"><p>x</p></section>',
    )
    code, out = run(html)
    assert code == 1, out
    assert "decision-cta" in out


def test_decision_basis_required_when_estimate_declares_it() -> None:
    # When estimation-infra.json declares recommendation.decision_basis, the report
    # must render a decision-basis section.
    import json as _json

    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "estimation-infra.json").write_text(
            _json.dumps(
                {"recommendation": {"outcome": "go_conditional", "decision_basis": "x"}}
            ),
            encoding="utf-8",
        )
        code, out = run(GOOD, migration_dir=d)
    assert code == 1, out
    assert "decision-basis" in out


def test_decision_basis_commented_placeholder_does_not_satisfy() -> None:
    # The shipped skeleton's commented decision-basis placeholder must not count.
    import json as _json

    html = GOOD.replace(
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>',
        "<!-- <section id=\"decision-basis\">when Estimate declares it</section> -->"
        '<section id="next-steps"><ol><li>See MIGRATION_GUIDE.md</li></ol></section>',
    )
    with tempfile.TemporaryDirectory() as tmp:
        d = Path(tmp)
        (d / "estimation-infra.json").write_text(
            _json.dumps(
                {"recommendation": {"outcome": "go_conditional", "decision_basis": "x"}}
            ),
            encoding="utf-8",
        )
        code, out = run(html, migration_dir=d)
    assert code == 1, out
    assert "decision-basis" in out