"""Kiểm thử phần lõi bằng thiết bị giả lập (không cần thiết bị thật).
Chạy:  python -m unittest discover -s tests -v
"""
import os
import sys
import tempfile
import threading
import unittest
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
os.environ["NETAUTO_HOME"] = tempfile.mkdtemp(prefix="netauto_test_")

from core import config_tools as ct, importer, scanner  # noqa: E402
from core.database import Database  # noqa: E402
from core.engine import Engine, is_read_only_command  # noqa: E402
from core.paths import data_dir  # noqa: E402
from core import security  # noqa: E402
from core.security import AuthError, Vault  # noqa: E402

security.ITERATIONS = 2000  # chỉ dùng trong test cho nhanh
from core.templating import TaskCatalog, TaskUnsupported, TemplateError  # noqa: E402
from drivers.base import MockDriver  # noqa: E402


def make_env():
    home = Path(tempfile.mkdtemp(prefix="netauto_env_"))
    for sub in ("backups", "logs", "custom_templates"):
        (home / sub).mkdir()
    db = Database(home / "t.db")
    vault = Vault(db)
    vault.initialize("admin", "Admin@12345")
    eng = Engine(db, vault, home)
    cat = TaskCatalog(ROOT, home / "custom_templates")
    MockDriver.reset()
    return home, db, vault, eng, cat


class TestSecurity(unittest.TestCase):
    def test_login_roles_encrypt(self):
        _, db, vault, _, _ = make_env()
        tok = vault.encrypt("Pa55")
        self.assertNotIn("Pa55", tok)
        self.assertEqual(vault.decrypt(tok), "Pa55")
        vault.add_user("op1", "Operator@123", "operator")
        v2 = Vault(db)
        v2.login("op1", "Operator@123")
        self.assertEqual(v2.decrypt(tok), "Pa55")          # cùng khóa dữ liệu
        self.assertTrue(v2.can("run_tasks"))
        self.assertFalse(v2.can("manage_users"))
        with self.assertRaises(AuthError):
            Vault(db).login("op1", "sai-mat-khau")
        with self.assertRaises(AuthError):
            v2.add_user("x", "Abcdefgh1", "viewer")           # operator không được tạo user

    def test_weak_password(self):
        db = Database(Path(tempfile.mkdtemp()) / "x.db")
        with self.assertRaises(AuthError):
            Vault(db).initialize("a", "123")


class TestConfigTools(unittest.TestCase):
    CUR = "hostname SW1\n!\nvlan 10\n name USERS\n!\ninterface Gi0/1\n description PC\n switchport access vlan 10\n"
    TGT = "hostname SW1\n!\ninterface Gi0/1\n description PC\n switchport access vlan 1\n"

    def test_rollback_commands(self):
        cmds, warns = ct.rollback_commands(self.CUR, self.TGT, "no")
        self.assertEqual(cmds, ["no vlan 10", "interface Gi0/1", "no switchport access vlan 10",
                                "switchport access vlan 1", "exit"])
        self.assertEqual(warns, [])

    def test_no_change(self):
        cmds, warns = ct.rollback_commands(self.CUR, self.CUR, "no")
        self.assertEqual(cmds, [])
        self.assertTrue(warns)

    def test_junos_and_huawei_negate(self):
        self.assertEqual(ct.negate("set system ntp server 1.1.1.1", "junos"), "delete system ntp server 1.1.1.1")
        self.assertEqual(ct.negate("sysname A", "undo"), "undo sysname A")
        self.assertEqual(ct.negate("undo x", "undo"), "x")
        self.assertEqual(ct.negate("no shutdown", "no"), "shutdown")

    def test_normalize_ignores_noise(self):
        a = "Building configuration...\nCurrent configuration : 100 bytes\nhostname A\n"
        b = "Building configuration...\nCurrent configuration : 999 bytes\nhostname A\n"
        self.assertEqual(ct.config_hash(a), ct.config_hash(b))


class TestTemplates(unittest.TestCase):
    def setUp(self):
        self.cat = TaskCatalog(ROOT, Path(tempfile.mkdtemp()))
        self.dev = {"name": "SW1", "ip": "10.0.0.1", "site": "HN", "vendor": "cisco_ios"}

    def test_cisco_access(self):
        out = self.cat.render("port_access", self.dev, {"ports": "Gi0/1,Gi0/2", "vlan_id": "20", "portfast": True})
        self.assertEqual(out[:4], ["interface Gi0/1", "switchport mode access", "switchport access vlan 20",
                                   "spanning-tree portfast"])

    def test_validation(self):
        with self.assertRaises(TemplateError):
            self.cat.render("vlan", self.dev, {"vlan_id": "9999"})
        with self.assertRaises(TemplateError):
            self.cat.render("snmp", self.dev, {})

    def test_unsupported_and_custom(self):
        dev = dict(self.dev, vendor="dell_os10")
        with self.assertRaises(TaskUnsupported):
            self.cat.render("vlan", dev, {"vlan_id": "10"})
        out = self.cat.render_custom("hostname {{ device.name }}-{{ s }}", dev, {"s": "x"})
        self.assertEqual(out, ["hostname SW1-x"])

    def test_every_family_renders(self):
        from drivers.vendors import VENDORS
        from tests.sample_vars import variables
        for key in {v.family: k for k, v in VENDORS.items()}.values():
            for t in self.cat.task_ids():
                d = dict(self.dev, vendor=key)
                if self.cat.supported(t, key):
                    self.assertTrue(self.cat.render(t, d, variables(t)), f"{key}/{t} rỗng")

    def render(self, task, vendor, **kw):
        from tests.sample_vars import variables
        return self.cat.render(task, dict(self.dev, vendor=vendor), variables(task, **kw))

    def test_cisco_juniper_coverage(self):
        """Cisco IOS và Junos phải có đủ bộ tác vụ L2/L3/bảo mật."""
        must = ["svi", "static_route", "ospf", "acl", "stp", "lacp", "port_security", "snmp_v3", "gateway_redundancy",
                "dhcp_relay", "dhcp_pool", "harden", "vlan_bulk", "vlan_delete", "port_settings", "storm_control"]
        for vendor in ("cisco_ios", "juniper_junos"):
            for t in must:
                self.assertTrue(self.cat.supported(t, vendor), f"{vendor} thiếu {t}")
        self.assertGreaterEqual(sum(self.cat.supported(t, "cisco_ios") for t in self.cat.task_ids()), 30)
        self.assertGreaterEqual(sum(self.cat.supported(t, "juniper_junos") for t in self.cat.task_ids()), 30)

    def test_l3_commands(self):
        self.assertEqual(self.render("svi", "cisco_ios")[-3:], ["ip helper-address 10.0.0.5", "no shutdown", "exit"])
        self.assertIn("ip address 10.10.10.2 255.255.255.0", self.render("svi", "cisco_ios"))
        self.assertIn("ip address 10.10.10.2/24", self.render("svi", "cisco_nxos"))
        self.assertIn("set interfaces irb unit 10 family inet address 10.10.10.2/24", self.render("svi", "juniper_junos"))
        self.assertEqual(self.render("static_route", "cisco_ios"), ["ip route 192.168.50.0 255.255.255.0 10.0.0.1 5"])
        self.assertEqual(self.render("static_route", "juniper_junos"),
                         ["set routing-options static route 192.168.50.0/24 next-hop 10.0.0.1 preference 5"])
        self.assertIn("network 10.10.10.0 0.0.0.255 area 0", self.render("ospf", "cisco_ios"))
        self.assertIn("set protocols ospf area 0.0.0.0 interface Vlan10", self.render("ospf", "juniper_junos"))

    def test_acl_and_security(self):
        self.assertIn("20 permit tcp 10.1.1.0 0.0.0.255 any eq 443", self.render("acl", "cisco_ios"))
        j = self.render("acl", "juniper_junos", apply_if="irb.10")
        self.assertIn("set firewall family inet filter BLOCK term T20 from source-address 10.1.1.0/24", j)
        self.assertIn("set firewall family inet filter BLOCK term T20 then accept", j)
        self.assertIn("set interfaces irb unit 10 family inet filter input BLOCK", j)
        self.assertIn("set firewall family inet filter BLOCK term T20 then discard", self.render("acl", "juniper_junos", action="deny"))
        self.assertIn("switchport port-security maximum 2", self.render("port_security", "cisco_ios"))
        self.assertIn("set snmp view ALL oid .1 include", self.render("snmp_v3", "juniper_junos"))

    def test_lacp_stp_vlan_bulk(self):
        self.assertIn("channel-group 1 mode active", self.render("lacp", "cisco_ios"))
        self.assertIn("set interfaces Gi1/0/1 ether-options 802.3ad ae1", self.render("lacp", "juniper_junos"))
        self.assertIn("set protocols rstp bridge-priority 4k", self.render("stp", "juniper_junos"))
        self.assertEqual(self.render("vlan_bulk", "cisco_ios")[:3], ["vlan 10", "name USERS", "exit"])
        self.assertIn("set vlans VLAN30 vlan-id 30", self.render("vlan_bulk", "juniper_junos"))

    def test_new_validation(self):
        for task, vendor, kw in [("svi", "cisco_ios", {"ip_cidr": "10.10.10.2"}), ("static_route", "cisco_ios", {"next_hop": "abc"}),
                                 ("storm_control", "cisco_ios", {"level": "500"}), ("acl", "cisco_ios", {"action": "allow"}),
                                 ("gateway_redundancy", "juniper_junos", {"ip_cidr": ""}), ("dhcp_pool", "juniper_junos", {"range_start": ""}),
                                 ("vlan_bulk", "cisco_ios", {"vlans": "9999 X"})]:
            with self.assertRaises(TemplateError, msg=f"{task} {kw}"):
                self.render(task, vendor, **kw)


class TestEngine(unittest.TestCase):
    def setUp(self):
        self.home, self.db, self.vault, self.eng, self.cat = make_env()

    def add(self, name, ip, vendor="mock"):
        self.db.add_device(name=name, ip=ip, vendor=vendor, username="a", password_enc=self.vault.encrypt("p"))
        return self.db.find_device_by_ip(ip)

    def builder(self, task, variables):
        return lambda dev, idx: self.cat.render(task, dev, variables, idx)

    def test_apply_diff_and_rollback(self):
        d = self.add("SW1", "10.1.1.1")
        _, res = self.eng.run_job([d], self.builder("vlan", {"vlan_id": "30", "vlan_name": "GUEST"}),
                                  "Tạo VLAN 30", dry_run=False, workers=1)
        r = res[0]
        self.assertEqual(r.status, "success", r.message)
        self.assertIn("+vlan 30", r.diff)
        before = self.db.get_backup(r.backup_before)["config"]
        self.assertNotIn("vlan 30", before)
        cmds, warns, _ = self.eng.preview_rollback(d, r.backup_before)
        self.assertIn("no vlan 30", cmds)
        rb = self.eng.rollback(d, r.backup_before, cmds)
        self.assertEqual(rb.status, "success", rb.message)
        now_cfg = MockDriver.STORE[d["ip"] + "|mock"]
        self.assertNotIn("vlan 30", now_cfg)
        # cấu hình quay về đúng như trước
        now_text = "Building configuration...\n" + "\n".join(now_cfg) + "\nend"
        self.assertEqual(ct.config_hash(now_text), ct.config_hash(before))

    def test_l3_tasks_and_rollback_on_mock(self):
        from tests.sample_vars import variables
        d = self.add("L3SW", "10.9.0.1")
        for task in ("svi", "static_route", "acl", "gateway_redundancy"):
            _, res = self.eng.run_job([d], self.builder(task, variables(task)), task, dry_run=False, workers=1)
            self.assertEqual(res[0].status, "success", f"{task}: {res[0].message}")
        cfg = "\n".join(MockDriver.STORE[d["ip"] + "|mock"])
        self.assertIn("interface Vlan10", cfg)
        self.assertIn("ip route 192.168.50.0 255.255.255.0 10.0.0.1 5", cfg)
        first = self.db.list_backups(d["id"])[-1]["id"]             # bản sao lưu đầu tiên (trước mọi thay đổi)
        cmds, _, _ = self.eng.preview_rollback(d, first)
        self.assertTrue(cmds)
        self.assertEqual(self.eng.rollback(d, first, cmds).status, "success")
        cfg = "\n".join(MockDriver.STORE[d["ip"] + "|mock"])
        self.assertNotIn("interface Vlan10", cfg)
        self.assertNotIn("ip route 192.168.50.0", cfg)

    def test_dry_run_does_not_change(self):
        d = self.add("SW2", "10.1.1.2")
        _, res = self.eng.run_job([d], self.builder("hostname", {"hostname": "NEW"}), "đổi tên", dry_run=True)
        self.assertEqual(res[0].status, "dry_run")
        self.assertIn("hostname SW2", MockDriver.STORE[d["ip"] + "|mock"])

    def test_multi_device_mixed_results(self):
        devs = [self.add("OK1", "10.2.0.1"), self.add("fail-auth", "10.2.0.2"),
                self.add("timeout-sw", "10.2.0.3"), self.add("badcmd-sw", "10.2.0.4"),
                self.add("OLD", "10.2.0.5", vendor="dell_os10")]
        _, res = self.eng.run_job(devs, self.builder("snmp", {"community": "abc"}), "snmp",
                                  dry_run=False, workers=4)
        by = {r.name: r for r in res}
        self.assertEqual(by["OK1"].status, "success")
        self.assertEqual(by["fail-auth"].status, "failed")
        self.assertIn("Sai tên đăng nhập", by["fail-auth"].message)
        self.assertEqual(by["timeout-sw"].status, "failed")
        self.assertEqual(by["badcmd-sw"].status, "warning")
        self.assertEqual(by["OLD"].status, "skipped")
        job = self.db.list_jobs(1)[0]
        self.assertEqual(job["total"], 5)
        self.assertEqual(len(self.db.job_results(job["id"])), 5)

    def test_backup_and_drift(self):
        d = self.add("SW3", "10.3.0.1")
        ok, msg, drift = self.eng.backup_device(d)
        self.assertTrue(ok)
        self.assertFalse(drift)
        ok, _, drift = self.eng.backup_device(d)
        self.assertEqual(len(self.db.list_backups(d["id"])), 1)    # không đổi -> không tạo bản mới
        MockDriver.STORE[d["ip"] + "|mock"].append("ntp server 9.9.9.9")      # ai đó sửa tay
        ok, msg, drift = self.eng.backup_device(d)
        self.assertTrue(drift)
        self.assertEqual(len(self.db.list_backups(d["id"])), 2)
        self.assertTrue(Path(self.db.last_backup(d["id"])["path"]).exists())

    def test_cancel(self):
        d = self.add("SW4", "10.4.0.1")
        ev = threading.Event()
        ev.set()
        _, res = self.eng.run_job([d], self.builder("vlan", {"vlan_id": "5"}), "x", dry_run=False, cancel=ev)
        self.assertEqual(res[0].status, "cancelled")

    def test_events_and_report(self):
        events = []
        self.eng.emit = lambda kind, **kw: events.append(kind)
        d = self.add("SW5", "10.5.0.1")
        job_id, _ = self.eng.run_job([d], self.builder("vlan", {"vlan_id": "7"}), "v7", dry_run=False)
        self.assertEqual(events.count("result"), 1)
        self.assertIn("job_done", events)
        for ext in ("html", "csv", "xlsx"):
            p = self.home / f"rep.{ext}"
            importer.export_job_report(p, self.db.get_job(job_id), self.db.job_results(job_id))
            self.assertTrue(p.exists() and p.stat().st_size > 50)

    def test_import_export_csv(self):
        p = self.home / "in.csv"
        importer.write_template_csv(p)
        st = importer.import_devices(p, self.db, self.vault)
        self.assertEqual((st["added"], st["updated"]), (3, 0), st)
        st2 = importer.import_devices(p, self.db, self.vault)
        self.assertEqual((st2["added"], st2["updated"]), (0, 3))
        dev = self.db.find_device_by_ip("192.168.1.10")
        self.assertNotEqual(dev["password_enc"], "MatKhau@123")
        self.assertEqual(self.vault.decrypt(dev["password_enc"]), "MatKhau@123")
        out = self.home / "out.csv"
        self.assertEqual(importer.export_devices(out, self.db), 3)
        self.assertNotIn("MatKhau", out.read_text(encoding="utf-8-sig"))


class TestSafetyFeatures(unittest.TestCase):
    """Nhóm an toàn: che mật khẩu, khóa SSH, commit confirmed, kiểm tra trước/sau, dừng khi lỗi, chống tự khóa."""

    def setUp(self):
        from core.config_facts import FactsStore
        self.home, self.db, self.vault, self.eng, self.cat = make_env()
        self.facts = FactsStore(self.db)

    def add(self, name, ip, vendor, model=""):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1, model=model)
        return self.db.find_device_by_ip(ip)

    def builder(self, task, **kw):
        from tests.sample_vars import variables
        v = variables(task, **kw)
        return lambda dev, i: self.cat.render(task, dev, v, i)

    # ---- che mật khẩu ----
    def test_secrets_redacted_everywhere(self):
        from core.redact import redact_lines, redact_text
        secrets = {"Pa55w0rd!": ["user_add"], "12345678": ["wifi_ssid"], "k3y": ["aaa_radius"], "authpass1": ["snmp_v3"], "privpass1": ["snmp_v3"], "s3cr3t-comm": ["snmp"]}
        cases = [("cisco_ios", t) for t in ("user_add", "snmp", "snmp_v3", "aaa_radius")] + \
                [("cisco_nxos", t) for t in ("user_add", "snmp", "snmp_v3")] + \
                [("juniper_junos", t) for t in ("user_add", "snmp", "snmp_v3", "aaa_radius")] + \
                [("mikrotik_routeros", t) for t in ("user_add", "snmp", "wifi_ssid")] + [("cisco_ap", "wifi_ssid"), ("openwrt", "wifi_ssid"),
                 ("huawei", "snmp"), ("hp_comware", "snmp"), ("aruba_os", "snmp")]
        from tests.sample_vars import variables
        for vendor, task in cases:
            v = variables(task, community="s3cr3t-comm", wifi_password="12345678")
            cmds = self.cat.render(task, {"name": "x", "ip": "1.1.1.1", "site": "s", "vendor": vendor}, v)
            red = "\n".join(redact_lines(cmds))
            for sec in ("Pa55w0rd!", "12345678", "k3y", "authpass1", "privpass1", "s3cr3t-comm"):
                if sec in "\n".join(cmds):
                    self.assertNotIn(sec, red, f"{vendor}/{task}: '{sec}' lộ trong:\n{red}")
        self.assertEqual(redact_text("hostname SW1"), "hostname SW1")           # không che nhầm lệnh thường
        self.assertEqual(redact_text("vlan 10\nname USERS"), "vlan 10\nname USERS")

    def test_job_history_has_no_secrets(self):
        d = self.add("S1", "10.2.0.1", "cisco_ios")
        job_id, res = self.eng.run_job([d], self.builder("user_add"), "user", dry_run=False, workers=1)
        self.assertEqual(res[0].status, "success")
        stored = "\n".join(r["commands"] + r["output"] + r["diff"] for r in self.db.job_results(job_id))
        self.assertNotIn("Pa55w0rd!", stored)
        self.assertNotIn("Pa55w0rd!", "\n".join(res[0].commands) + res[0].output + res[0].diff)
        self.assertIn("username u1", stored)                                    # vẫn thấy lệnh, chỉ che bí mật

    # ---- khóa SSH ----
    def test_host_keys(self):
        from drivers import hostkeys
        from drivers.base import friendly_error
        f = self.home / "known_hosts"
        f.write_text("10.0.0.1 ssh-ed25519 AAAAC3Nza\n[10.0.0.2]:2222 ssh-rsa AAAAB3\n# c\n", encoding="utf-8")
        self.assertTrue(hostkeys.is_known(f, "10.0.0.1"))
        self.assertTrue(hostkeys.is_known(f, "10.0.0.2", 2222))
        self.assertFalse(hostkeys.is_known(f, "10.0.0.2", 22))
        self.assertFalse(hostkeys.is_known(f, "10.0.0.9"))
        self.assertEqual(hostkeys.netmiko_kwargs("off", f, "h"), {})
        self.assertEqual(hostkeys.netmiko_kwargs("tofu", f, "h"), {"alt_host_keys": True, "alt_key_file": str(f)})
        self.assertTrue(hostkeys.netmiko_kwargs("strict", f, "h")["ssh_strict"])
        self.assertEqual(hostkeys.forget_host(f, "10.0.0.1"), 1)
        self.assertFalse(hostkeys.is_known(f, "10.0.0.1"))
        self.assertTrue(hostkeys.is_known(f, "10.0.0.2", 2222))
        BadHostKeyException = type("BadHostKeyException", (Exception,), {})
        self.assertIn("ĐÃ THAY ĐỔI", friendly_error(BadHostKeyException("x")))

    # ---- commit confirmed ----
    def test_commit_confirmed_confirms_when_still_reachable(self):
        d = self.add("EX1", "10.3.0.1", "juniper_junos", "ex4300-48t")
        _, res = self.eng.run_job([d], self.builder("vlan", vlan_id="30", vlan_name="GUEST"), "v", dry_run=False, workers=1, safe_minutes=5)
        self.assertEqual(res[0].status, "success", res[0].message)
        self.assertIn("XÁC NHẬN", res[0].message)
        self.assertEqual(MockDriver.PENDING, {})
        self.assertTrue(any("vlan-id 30" in ln for ln in MockDriver.STORE[MockDriver.key_for(d["ip"], "juniper_junos")]))

    def test_commit_confirmed_auto_reverts_when_access_lost(self):
        d = self.add("EX-lostaccess", "10.3.0.2", "juniper_srx", "srx300")
        key = MockDriver.key_for(d["ip"], "juniper_srx")
        before = list(MockDriver(self.eng.conn_params(d))._state())
        _, res = self.eng.run_job([d], self.builder("srx_zone", zone_name="dmz", zone_ifaces="ge-0/0/2"), "z", dry_run=False, workers=1, safe_minutes=5)
        r = res[0]
        self.assertEqual(r.status, "warning", r.message)
        self.assertIn("TỰ HOÀN TÁC", r.message)
        self.assertIn(key, MockDriver.PENDING)
        self.assertTrue(any("security-zone dmz" in ln for ln in MockDriver.STORE[key]))        # đang áp dụng tạm
        self.assertTrue(MockDriver.expire_pending(d["ip"], "juniper_srx"))                     # hết hạn -> thiết bị tự quay lại
        self.assertEqual(MockDriver.STORE[key], before)

    def test_safe_mode_ignored_for_cisco(self):
        d = self.add("C1", "10.3.0.3", "cisco_ios")
        _, res = self.eng.run_job([d], self.builder("vlan", vlan_id="30", vlan_name="G"), "v", dry_run=False, workers=1, safe_minutes=5)
        self.assertEqual(res[0].status, "success")
        self.assertNotIn("XÁC NHẬN", res[0].message)

    # ---- kiểm tra trước/sau ----
    def test_health_check_flags_lost_interface(self):
        d = self.add("C2", "10.4.0.1", "cisco_ios")
        _, res = self.eng.run_job([d], self.builder("port_settings", ports="GigabitEthernet0/2", admin="disable", speed="keep", duplex="keep", description=""),
                                  "shut", dry_run=False, workers=1, verify=True)
        self.assertEqual(res[0].status, "warning", res[0].message)
        self.assertIn("SAU THAY ĐỔI", res[0].message)
        self.assertIn("Số giao diện đang up: 3 → 2", res[0].output)
        _, res = self.eng.run_job([d], self.builder("vlan", vlan_id="40", vlan_name="X"), "v", dry_run=False, workers=1, verify=True)
        self.assertEqual(res[0].status, "success", res[0].message)
        self.assertIn("KIỂM TRA TRƯỚC/SAU", res[0].output)

    # ---- dừng khi lỗi / chạy thử đợt đầu ----
    def test_stop_on_error_and_canary(self):
        devs = [self.add("ok1", "10.5.0.1", "cisco_ios"), self.add("fail-2", "10.5.0.2", "cisco_ios"),
                self.add("ok3", "10.5.0.3", "cisco_ios"), self.add("ok4", "10.5.0.4", "cisco_ios")]
        b = self.builder("vlan", vlan_id="50", vlan_name="X")
        _, res = self.eng.run_job(devs, b, "v", dry_run=False, workers=1, stop_on_error=True)
        st = {r.name: r.status for r in res}
        self.assertEqual((st["ok1"], st["fail-2"], st["ok3"], st["ok4"]), ("success", "failed", "cancelled", "cancelled"))
        self.assertIn("dừng", next(r for r in res if r.name == "ok3").message)
        _, res = self.eng.run_job(devs, b, "v", dry_run=False, workers=1, stop_on_error=False)       # không dừng: các máy còn lại vẫn chạy
        self.assertEqual({r.name: r.status for r in res}["ok4"], "success")
        # canary: máy đầu lỗi -> không đụng tới các máy sau
        devs2 = [self.add("fail-first", "10.5.0.5", "cisco_ios"), self.add("b1", "10.5.0.6", "cisco_ios"), self.add("b2", "10.5.0.7", "cisco_ios")]
        _, res = self.eng.run_job(devs2, b, "v", dry_run=False, workers=3, stop_on_error=True, canary=1)
        st = {r.name: r.status for r in res}
        self.assertEqual((st["fail-first"], st["b1"], st["b2"]), ("failed", "cancelled", "cancelled"))
        self.assertNotIn(MockDriver.key_for("10.5.0.6", "cisco_ios"), MockDriver.STORE)        # máy sau chưa hề bị kết nối

    # ---- chống tự khóa mình ----
    def test_lockout_guard_cisco(self):
        from core import guard
        d = self.add("L3", "10.10.10.2", "cisco_ios")
        self.eng.run_job([d], self.builder("svi", vlan_id="10", vlan_name="U"), "svi", dry_run=False, workers=1)
        facts = self.facts.get(d)
        self.assertEqual(guard.mgmt_interfaces(d, facts, "ios")[0], ["Vlan10"])
        w = guard.check(d, facts, ["no vlan 10"])
        self.assertTrue(any("VLAN 10" in x for x in w), w)
        w = guard.check(d, facts, ["interface Vlan10", "shutdown", "exit"])
        self.assertTrue(any("shutdown" in x and "Vlan10" in x for x in w), w)
        self.assertEqual(guard.check(d, facts, ["interface GigabitEthernet0/3", "shutdown", "exit"]), [])   # cổng khác: an toàn
        self.assertEqual(guard.check(d, facts, ["vlan 99", "name X", "exit"]), [])
        w = guard.check(d, facts, ["line vty 0 15", "transport input telnet", "exit"])
        self.assertTrue(any("tắt SSH" in x for x in w), w)

    def test_lockout_guard_junos_and_telnet(self):
        from core import guard
        d = self.add("FW", "192.168.1.1", "juniper_srx", "srx300")                      # baseline: ge-0/0/1 giữ 192.168.1.1
        self.eng.backup_device(d)
        facts = self.facts.get(d)
        self.assertIn("ge-0/0/1", guard.mgmt_interfaces(d, facts, "junos_srx")[0])
        self.assertTrue(guard.check(d, facts, ["set interfaces ge-0/0/1 disable"]))
        self.assertTrue(guard.check(d, facts, ["delete security zones security-zone trust"]))
        self.assertTrue(guard.check(d, facts, ["delete system services ssh"]))
        self.assertEqual(guard.check(d, facts, ["set interfaces ge-0/0/0 disable"]), [])
        t = dict(d, protocol="telnet")
        self.assertTrue(any("Telnet" in x for x in guard.check(t, facts, ["delete system services telnet"])))


class TestNewTasks(unittest.TestCase):
    """TACACS+, BGP, SPAN, DAI, IPsec SRX, chèn policy theo thứ tự, cảnh báo 'VLAN đang được dùng'."""

    def setUp(self):
        from core.config_facts import FactsStore
        self.home, self.db, self.vault, self.eng, self.cat = make_env()
        self.facts = FactsStore(self.db)

    def add(self, name, ip, vendor, model=""):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1, model=model)
        return self.db.find_device_by_ip(ip)

    def run_task(self, d, task, expect="success", **kw):
        from tests.sample_vars import variables
        v = variables(task, **kw)
        _, res = self.eng.run_job([d], lambda dev, i: self.cat.render(task, dev, v, i), task, dry_run=False, workers=1)
        self.assertEqual(res[0].status, expect, f"{task}: {res[0].message}")
        return res[0]

    def render(self, task, vendor, **kw):
        from tests.sample_vars import variables
        return self.cat.render(task, {"name": "x", "ip": "1.1.1.1", "site": "s", "vendor": vendor}, variables(task, **kw))

    def test_support_matrix(self):
        for t in ("tacacs", "bgp", "span"):
            for v in ("cisco_ios", "cisco_nxos", "juniper_junos"):
                self.assertTrue(self.cat.supported(t, v), f"{t}/{v}")
        self.assertTrue(self.cat.supported("tacacs", "juniper_srx") and self.cat.supported("bgp", "juniper_srx"))
        self.assertTrue(self.cat.supported("dai", "cisco_ios") and not self.cat.supported("dai", "juniper_srx"))
        self.assertTrue(self.cat.supported("srx_ipsec", "juniper_srx") and not self.cat.supported("srx_ipsec", "juniper_junos"))
        self.assertFalse(self.cat.supported("span", "juniper_srx"))

    def test_commands(self):
        ios = self.render("bgp", "cisco_ios")
        self.assertIn("router bgp 65001", ios)
        self.assertIn("neighbor 10.0.0.2 remote-as 65002", ios)
        self.assertIn("network 10.10.0.0 mask 255.255.255.0", ios)
        j = self.render("bgp", "juniper_junos")
        self.assertIn("set protocols bgp group PEERS type external", j)
        self.assertIn("set protocols bgp group PEERS neighbor 10.0.0.2 peer-as 65002", j)
        self.assertIn("set policy-options policy-statement BGP-EXPORT term T2 from route-filter 10.20.0.0/24 exact", j)
        self.assertIn("set protocols bgp group PEERS type internal", self.render("bgp", "juniper_junos", remote_as="65001"))
        self.assertIn("set system tacplus-server 10.0.0.9 secret \"k3y\"", self.render("tacacs", "juniper_junos"))
        self.assertIn("aaa authentication login default group tacacs+ local", self.render("tacacs", "cisco_ios"))
        self.assertIn("monitor session 1 source interface Gi0/2 both", self.render("span", "cisco_ios"))
        self.assertIn("set forwarding-options analyzer SPAN1 input egress interface Gi0/1", self.render("span", "juniper_junos"))
        self.assertNotIn("input egress", "\n".join(self.render("span", "juniper_junos", span_dir="rx")))
        self.assertIn("ip arp inspection vlan 10,20", self.render("dai", "cisco_ios"))
        ip = self.render("srx_ipsec", "juniper_srx")
        self.assertIn("set security ike gateway HN-HCM-gw version v2-only", ip)
        self.assertIn("set security ipsec vpn HN-HCM bind-interface st0.0", ip)
        self.assertIn("set routing-options static route 10.20.0.0/16 next-hop st0.0", ip)
        self.assertIn("set security ike policy HN-HCM-ike-pol mode main", self.render("srx_ipsec", "juniper_srx", ike_ver="v1"))
        with self.assertRaises(TemplateError):
            self.render("bgp", "cisco_ios", local_as="99999999999")
        with self.assertRaises(TemplateError):
            self.render("srx_policy", "juniper_srx", position="before", ref_policy="")        # thiếu policy mốc

    def test_apply_on_simulated_devices(self):
        for vendor, tasks in (("cisco_ios", ("bgp", "span", "dai", "tacacs")), ("cisco_nxos", ("bgp", "span", "dai", "tacacs")),
                              ("juniper_junos", ("bgp", "span", "tacacs")), ("juniper_srx", ("srx_ipsec", "bgp", "tacacs"))):
            d = self.add(f"N-{vendor}", f"10.9.{abs(len(vendor))}.{len(tasks)}", vendor, "srx300" if vendor == "juniper_srx" else "")
            for t in tasks:
                kw = dict(zone_name="vpn") if t == "srx_ipsec" else {}
                self.run_task(d, t, **kw)
        r = self.db.job_results(self.db.list_jobs(1)[0]["id"])[0]
        self.assertNotIn("k3y", r["commands"])

    def test_srx_policy_ordering_with_insert(self):
        d = self.add("FW-ORD", "10.9.9.1", "juniper_srx", "srx300")
        self.run_task(d, "srx_zone", zone_name="dmz", zone_ifaces="ge-0/0/2")
        for name in ("P1", "P2"):
            self.run_task(d, "srx_policy", policy_name=name, to_zone="untrust", source="any", application="any")
        self.run_task(d, "srx_policy", policy_name="P3", to_zone="untrust", source="any", application="any", position="before", ref_policy="P1")
        self.run_task(d, "srx_policy", policy_name="P4", to_zone="untrust", source="any", application="any", position="after", ref_policy="P1")
        out = self.eng.run_show(d, "show security policies")
        order = [ln.split("Policy: ")[1].split(",")[0] for ln in out.split("\n") if "Policy: " in ln and "trust to-zone" not in ln]
        self.assertEqual(order, ["default-permit", "P3", "P1", "P4", "P2"], order)       # đúng thứ tự khi chèn trước/sau
        r = self.run_task(d, "srx_policy", expect="warning", policy_name="P9", to_zone="untrust", source="any", application="any",
                          position="before", ref_policy="KHONG-CO")
        self.assertIn("không tồn tại", r.output)

    def test_warning_when_deleting_vlan_in_use(self):
        from core.config_facts import validate_links
        from tests.sample_vars import variables
        d = self.add("SW-U", "10.9.8.1", "cisco_ios")
        self.eng.backup_device(d)
        self.run_task(d, "vlan", vlan_id="30", vlan_name="GUEST")
        self.run_task(d, "port_access", ports="GigabitEthernet0/2", vlan_id="30", vlan_name="GUEST", description="PC", portfast=False)
        self.run_task(d, "port_trunk", ports="GigabitEthernet0/1", allowed_vlans="10,30-35", native_vlan="", encap=False)
        fields = self.cat.fields_for("vlan_delete", ["ios"])
        w = validate_links(fields, variables("vlan_delete", vlan_id="30"), d, self.facts.get(d))
        self.assertTrue(any("ĐANG ĐƯỢC DÙNG" in x and "GigabitEthernet0/2 (access)" in x and "GigabitEthernet0/1 (trunk)" in x for x in w), w)
        self.assertEqual(validate_links(fields, variables("vlan_delete", vlan_id="31"), d, self.facts.get(d))[0].startswith("VLAN ID: VLAN 31 không có"), True)
        j = self.add("EX-U", "10.9.8.2", "juniper_junos", "ex4300-48t")
        self.eng.backup_device(j)
        self.run_task(j, "vlan", vlan_id="30", vlan_name="GUEST")
        self.run_task(j, "port_access", ports="ge-0/0/1", vlan_id="30", vlan_name="GUEST", description="PC", portfast=False)
        w = validate_links(self.cat.fields_for("vlan_delete", ["junos"]), variables("vlan_delete", vlan_id="30"), j, self.facts.get(j))
        self.assertTrue(any("ge-0/0/1" in x for x in w), w)
        free = validate_links(self.cat.fields_for("vlan_delete", ["junos"]), variables("vlan_delete", vlan_id="1"), j, self.facts.get(j))
        self.assertFalse(any("ĐANG ĐƯỢC DÙNG" in x for x in free), free)

    def test_ref_policy_must_exist(self):
        from core.config_facts import validate_links
        from tests.sample_vars import variables
        d = self.add("FW-R", "10.9.7.1", "juniper_srx", "srx300")
        self.eng.backup_device(d)
        f = self.cat.fields_for("srx_policy", ["junos_srx"])
        w = validate_links(f, variables("srx_policy", position="after", ref_policy="NOPE"), d, self.facts.get(d))
        self.assertTrue(any("NOPE" in x for x in w), w)
        self.assertEqual([x for x in validate_links(f, variables("srx_policy", position="after", ref_policy="default-permit", to_zone="untrust"),
                                                    d, self.facts.get(d)) if "default-permit" in x], [])


class TestDeployment(unittest.TestCase):
    """Biến theo từng thiết bị (CSV/Excel), hẹn giờ chạy, chính sách giữ backup, kiểm tra tuân thủ."""

    def setUp(self):
        from core.config_facts import FactsStore
        self.home, self.db, self.vault, self.eng, self.cat = make_env()
        self.facts = FactsStore(self.db)

    def add(self, name, ip, vendor="cisco_ios", model=""):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1, model=model)
        return self.db.find_device_by_ip(ip)

    # ---- biến theo thiết bị ----
    def test_per_device_variables_csv_and_excel(self):
        from core import pervar
        from core.jobs import build_payload, builder_from_payload
        a, b, c = self.add("SW-A", "10.1.0.1"), self.add("SW-B", "10.1.0.2"), self.add("SW-C", "10.1.0.3")
        f = self.home / "vars.csv"
        f.write_text("device,vlan_id,vlan_name\nSW-A,101,KHO\nSW-B,102,KETOAN\n10.1.0.3,103,IT\n", encoding="utf-8")
        table = pervar.load_table(f)
        self.assertEqual(pervar.lookup(table, a)["vlan_id"], "101")
        self.assertEqual(pervar.lookup(table, c)["vlan_name"], "IT")                 # tra theo IP
        payload = build_payload("vlan", {"vlan_id": "10", "vlan_name": "DEFAULT"}, table, "", {}, [a["id"], b["id"], c["id"]], {})
        builder = builder_from_payload(self.cat, payload)
        _, res = self.eng.run_job([a, b, c], builder, "vlan theo thiết bị", dry_run=False, workers=1)
        self.assertTrue(all(r.status == "success" for r in res), [r.message for r in res])
        for d, vid, name in ((a, "101", "KHO"), (b, "102", "KETOAN"), (c, "103", "IT")):
            cfg = "\n".join(MockDriver.STORE[MockDriver.key_for(d["ip"], "cisco_ios")])
            self.assertIn(f"vlan {vid}", cfg)
            self.assertIn(f" name {name}", cfg)
        # thiết bị không có dòng riêng dùng giá trị chung
        d2 = self.add("SW-D", "10.1.0.4")
        _, res = self.eng.run_job([d2], builder, "v", dry_run=False, workers=1)
        self.assertIn("vlan 10", "\n".join(MockDriver.STORE[MockDriver.key_for(d2["ip"], "cisco_ios")]))
        # file mẫu + Excel
        fields = self.cat.fields_for("vlan", ["ios"])
        for ext in ("csv", "xlsx"):
            t = self.home / f"mau.{ext}"
            pervar.write_template(t, [a, b], fields, {"vlan_id": "7"})
            back = pervar.load_table(t)
            self.assertEqual(back["sw-a"]["vlan_id"], "7")

    def test_bool_strings_from_csv(self):
        dev = {"name": "x", "ip": "1.1.1.1", "site": "", "vendor": "cisco_ios"}
        on = self.cat.render("port_access", dev, {"ports": "Gi0/1", "vlan_id": "10", "portfast": "true"})
        off = self.cat.render("port_access", dev, {"ports": "Gi0/1", "vlan_id": "10", "portfast": "false"})
        self.assertIn("spanning-tree portfast", on)
        self.assertNotIn("spanning-tree portfast", off)

    # ---- hẹn giờ ----
    def test_scheduled_job_runs_and_payload_is_encrypted(self):
        from datetime import datetime, timedelta
        from core.jobs import JobScheduler, build_payload, parse_when
        d = self.add("SCH1", "10.2.0.1")
        sch = JobScheduler(self.eng, self.db, self.vault, self.cat)
        payload = build_payload("user_add", {"username": "backup1", "password": "S3cretPass!"}, {}, "", {}, [d["id"]],
                                {"dry": False, "save": True, "workers": 1, "stop_on_error": True})
        with self.assertRaises(ValueError):
            sch.schedule(datetime.now() - timedelta(minutes=1), "quá khứ", payload)
        when = datetime.now() + timedelta(hours=2)
        jid = sch.schedule(when, "Tạo user lúc 2h", payload)
        raw = self.db.get_sched(jid)
        self.assertNotIn("S3cretPass!", raw["payload_enc"])                               # mật khẩu không nằm dạng rõ trong DB
        self.assertEqual(sch.run_due(), [])                                                # chưa đến giờ
        self.assertEqual(sch.run_due(now=when + timedelta(minutes=1)), [jid])
        row = self.db.get_sched(jid)
        self.assertEqual(row["status"], "done", row["result"])
        self.assertIn("1 thành công", row["result"])
        self.assertTrue(any("username backup1" in ln for ln in MockDriver.STORE[MockDriver.key_for(d["ip"], "cisco_ios")]))
        self.assertEqual(sch.run_due(now=when + timedelta(hours=1)), [])                   # không chạy lại
        jid2 = sch.schedule(datetime.now() + timedelta(hours=3), "sẽ hủy", payload)
        self.assertTrue(sch.cancel(jid2))
        self.assertEqual(sch.run_due(now=datetime.now() + timedelta(days=1)), [])
        self.assertEqual(parse_when("2030-01-02 03:04"), datetime(2030, 1, 2, 3, 4))
        self.assertGreater(parse_when("00:00"), datetime.now() - timedelta(seconds=1))
        with self.assertRaises(ValueError):
            parse_when("abc")

    def test_scheduled_custom_commands_and_deleted_device(self):
        from datetime import datetime, timedelta
        from core.jobs import JobScheduler, build_payload
        d = self.add("SCH2", "10.2.0.2")
        sch = JobScheduler(self.eng, self.db, self.vault, self.cat)
        pl = build_payload("__custom__", {}, {}, "hostname {{ device.name }}-{{ s }}", {"s": "NEW"}, [d["id"]], {"dry": False, "workers": 1})
        jid = sch.schedule(datetime.now() + timedelta(hours=1), "custom", pl)
        sch.run_due(now=datetime.now() + timedelta(hours=2))
        self.assertIn("hostname SCH2-NEW", MockDriver.STORE[MockDriver.key_for(d["ip"], "cisco_ios")])
        jid3 = sch.schedule(datetime.now() + timedelta(hours=1), "máy đã xóa", pl)
        self.db.delete_device(d["id"])
        sch.run_due(now=datetime.now() + timedelta(hours=2))
        self.assertEqual(self.db.get_sched(jid3)["status"], "failed")

    # ---- giữ backup ----
    def test_backup_retention(self):
        d = self.add("RET", "10.3.0.1")
        self.db.set_setting("retention_keep", 3)
        for i in range(8):
            MockDriver.STORE.setdefault(MockDriver.key_for(d["ip"], "cisco_ios"), MockDriver(self.eng.conn_params(d))._state())
            MockDriver.STORE[MockDriver.key_for(d["ip"], "cisco_ios")].append(f"ntp server 9.9.9.{i}")
            self.eng.backup_device(d, f"lần {i}")
        backs = self.db.list_backups(d["id"])
        self.assertEqual(len(backs), 3)
        self.assertIn("lần 7", backs[0]["note"])                                           # luôn giữ bản mới nhất
        files = list((self.home / "backups").rglob("*.cfg"))
        self.assertEqual(len(files), 3)                                                      # file cũ cũng bị xóa
        self.db.set_setting("retention_keep", 50)

    # ---- tuân thủ ----
    def test_compliance_cisco_improves_after_hardening(self):
        from core import compliance
        d = self.add("CMP1", "10.4.0.1")
        self.eng.backup_device(d)
        rows = compliance.run_compliance(self.db, self.facts, [d])
        st = {r["rule"]: r["status"] for r in rows}
        self.assertEqual(st["ios-ssh2"], "KHÔNG ĐẠT")
        self.assertEqual(st["cisco-ntp"], "đạt")                                            # baseline giả lập có ntp server
        before = compliance.score(rows)
        from tests.sample_vars import variables
        for task in ("harden", "secure_mgmt", "ntp_syslog", "banner"):
            v = variables(task)
            self.eng.run_job([d], lambda dev, i, t=task, v=v: self.cat.render(t, dev, v, i), task, dry_run=False, workers=1)
        rows = compliance.run_compliance(self.db, self.facts, [d])
        st = {r["rule"]: r["status"] for r in rows}
        self.assertEqual((st["ios-ssh2"], st["ios-telnet"], st["ios-http"], st["cisco-syslog"], st["cisco-banner"]), ("đạt",) * 5, st)
        self.assertGreater(compliance.score(rows), before)
        for ext in ("html", "csv", "xlsx"):
            p = self.home / f"cmp.{ext}"
            compliance.export(p, rows)
            self.assertTrue(p.stat().st_size > 50)

    def test_compliance_srx_any_any_and_mikrotik_telnet(self):
        from core import compliance
        fw = self.add("FW-C", "10.4.0.2", "juniper_srx", "srx300")
        self.eng.backup_device(fw)
        st = {r["rule"]: r for r in compliance.run_compliance(self.db, self.facts, [fw])}
        self.assertEqual(st["srx-anyany"]["status"], "KHÔNG ĐẠT")                          # baseline có default-permit any-any
        self.assertIn("trust→untrust:default-permit", st["srx-anyany"]["detail"])
        from tests.sample_vars import variables
        v = variables("srx_policy_delete", policy_name="default-permit")
        self.eng.run_job([fw], lambda dev, i: self.cat.render("srx_policy_delete", dev, v, i), "x", dry_run=False, workers=1)
        st = {r["rule"]: r for r in compliance.run_compliance(self.db, self.facts, [fw])}
        self.assertEqual(st["srx-anyany"]["status"], "đạt")
        mk = self.add("MK-C", "10.4.0.3", "mikrotik_routeros")
        self.eng.backup_device(mk)
        self.assertEqual({r["rule"]: r["status"] for r in compliance.run_compliance(self.db, self.facts, [mk])}["mt-telnet"], "KHÔNG ĐẠT")
        self.eng.run_job([mk], lambda dev, i: self.cat.render("secure_mgmt", dev, {}, i), "x", dry_run=False, workers=1)
        self.assertEqual({r["rule"]: r["status"] for r in compliance.run_compliance(self.db, self.facts, [mk])}["mt-telnet"], "đạt")
        nodata = self.add("NODATA", "10.4.0.4")
        self.assertEqual(compliance.run_compliance(self.db, self.facts, [nodata])[0]["status"], "chưa có dữ liệu")


class TestGuiSourceSanity(unittest.TestCase):
    """Kiểm tra tĩnh mã giao diện (môi trường test không có Tkinter thật): bắt các lỗi Tk hay gặp."""

    def test_no_empty_color_options(self):
        import re
        names = "bg|fg|background|foreground|insertbackground|highlightbackground|selectbackground"
        rx = re.compile(r"\b(" + names + r")\s*=\s*(\"\"|'')")
        for f in (ROOT / "gui").glob("*.py"):
            for n, line in enumerate(f.read_text(encoding="utf-8").split("\n"), start=1):
                if line.strip().startswith("#"):
                    continue
                # chuỗi rỗng ở điều kiện kiểu 'bg="" if ...' cũng không được phép
                self.assertIsNone(rx.search(line), f"{f.name}:{n}: màu rỗng/None sẽ gây TclError 'unknown color name': {line.strip()}")

    # tên phương thức/thuộc tính của Tkinter (Misc, Widget, Pack, Grid, Place, Wm, ttk.Widget...) - đặt trùng sẽ làm hỏng Tkinter
    TK_RESERVED = set("""after after_idle after_cancel bell bind bind_all bind_class bindtags cget clipboard_append clipboard_clear clipboard_get
        columnconfigure config configure deletecommand destroy event_add event_delete event_generate event_info focus focus_displayof
        focus_force focus_get focus_lastfor focus_set forget getboolean getdouble getint getvar grab_current grab_release grab_set
        grab_set_global grab_status grid grid_anchor grid_bbox grid_columnconfigure grid_configure grid_forget grid_info grid_location
        grid_propagate grid_remove grid_rowconfigure grid_size grid_slaves image_names image_types info keys lift location lower mainloop
        nametowidget option_add option_clear option_get option_readfile pack pack_configure pack_forget pack_info pack_propagate
        pack_slaves place place_configure place_forget place_info place_slaves propagate quit register rowconfigure selection_clear
        selection_get selection_handle selection_own selection_own_get send setvar size slaves tk_focusFollowsMouse tk_focusNext
        tk_focusPrev tk_setPalette tk_strictMotif tkraise unbind unbind_all unbind_class update update_idletasks wait_variable
        wait_visibility wait_window identify instate state title geometry resizable transient withdraw deiconify iconify protocol
        minsize maxsize overrideredirect attributes focusmodel frame group iconbitmap iconphoto manage aspect client command
        master tk children widgetName
        _options _w _name _root _register _bind _configure _getconfigure _getconfigure1 _displayof _nametowidget _substitute
        _report_exception _setup _tclCommands _last_child_ids _windowingsystem _noarg_ _getints _getdoubles _getboolean
        _gridconvvalue _grid_configure _destroy_children _do _configure_tcl _subst_format _subst_format_str""".split())

    def test_gui_classes_do_not_shadow_tkinter_internals(self):
        """Bắt lỗi kiểu 'TypeError: TasksTab._options() takes 1 positional argument but 2 were given' (đặt tên trùng nội bộ Tkinter)."""
        import ast
        widget_bases = {"Frame", "LabelFrame", "Toplevel", "Canvas", "Label", "Entry", "Text", "Notebook", "Treeview", "PanedWindow", "Tk"}
        problems = []
        for f in (ROOT / "gui").glob("*.py"):
            tree = ast.parse(f.read_text(encoding="utf-8"))
            for cls in [n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]:
                bases = {(b.attr if isinstance(b, ast.Attribute) else getattr(b, "id", "")) for b in cls.bases}
                if not (bases & widget_bases):
                    continue
                names = {n.name for n in cls.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))}
                for node in ast.walk(cls):
                    targets = node.targets if isinstance(node, ast.Assign) else ([node.target] if isinstance(node, (ast.AnnAssign, ast.AugAssign)) else [])
                    for t in targets:
                        if isinstance(t, ast.Attribute) and isinstance(t.value, ast.Name) and t.value.id == "self":
                            names.add(t.attr)
                for n in sorted(names & self.TK_RESERVED):
                    problems.append(f"{f.name}:{cls.name}.{n}")
        self.assertEqual(problems, [], "Tên trùng với nội bộ của Tkinter: " + ", ".join(problems))

    def test_all_gui_modules_compile(self):
        import py_compile
        for f in list((ROOT / "gui").glob("*.py")) + [ROOT / "main.py"]:
            py_compile.compile(str(f), doraise=True)


class TestLinkedConfig(unittest.TestCase):
    """Các ô nhập liên kết với cấu hình đang có trên thiết bị (VLAN đã tạo hiện ra khi gán cổng...)."""

    def setUp(self):
        from core.config_facts import FactsStore
        self.home, self.db, self.vault, self.eng, self.cat = make_env()
        self.facts = FactsStore(self.db)

    def add(self, name, ip, vendor, model=""):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1, model=model)
        return self.db.find_device_by_ip(ip)

    def run_task(self, d, task, **kw):
        from tests.sample_vars import variables
        v = variables(task, **kw)
        _, res = self.eng.run_job([d], lambda dev, i: self.cat.render(task, dev, v, i), task, dry_run=False, workers=1)
        self.assertEqual(res[0].status, "success", f"{task}: {res[0].message}")

    def opts(self, ref, devs):
        from core.config_facts import options_for
        return {o.value: o.label for o in options_for(ref, devs, self.facts)}

    def warns(self, task, d, **kw):
        from core.config_facts import validate_links
        from drivers.vendors import get_vendor
        from tests.sample_vars import variables
        fam = get_vendor(d["vendor"]).family
        return validate_links(self.cat.fields_for(task, [fam]), variables(task, **kw), d, self.facts.get(d))

    def test_vlan_created_then_offered_when_assigning_port(self):
        d = self.add("SW1", "10.1.0.1", "cisco_ios")
        self.eng.backup_device(d)
        self.assertNotIn("30", self.opts("vlan", [d]))
        self.run_task(d, "vlan", vlan_id="30", vlan_name="GUEST")
        o = self.opts("vlan", [d])
        self.assertEqual(o["30"], "30 — GUEST")                           # VLAN vừa tạo hiện ra để chọn
        self.assertEqual(self.warns("port_access", d, vlan_id="30", ports="GigabitEthernet0/2"), [])
        w = self.warns("port_access", d, vlan_id="77", ports="GigabitEthernet0/2")
        self.assertTrue(any("VLAN 77" in x and "CHƯA" in x for x in w), w)
        w = self.warns("vlan", d, vlan_id="30", vlan_name="X")           # tạo trùng
        self.assertTrue(any("ĐÃ tồn tại" in x for x in w), w)

    def test_ports_listed_with_details_and_typos_flagged_on_cisco(self):
        d = self.add("SW2", "10.1.0.2", "cisco_ios")
        self.eng.backup_device(d)
        o = self.opts("port", [d])
        self.assertIn("GigabitEthernet0/2", o)
        self.assertIn("vlan 1", o["GigabitEthernet0/2"])
        self.assertIn("uplink", o["GigabitEthernet0/1"])
        w = self.warns("port_access", d, vlan_id="1", ports="Gi0/2, Gi0/99")
        self.assertTrue(any("Gi0/99" in x for x in w) and not any("Gi0/2," in x for x in w), w)   # Gi0/2 == GigabitEthernet0/2

    def test_svi_and_gateway_dependency(self):
        d = self.add("L3", "10.1.0.3", "cisco_ios")
        self.eng.backup_device(d)
        self.assertTrue(self.warns("gateway_redundancy", d, vlan_id="10"))            # chưa có SVI
        self.assertTrue(self.warns("dhcp_relay", d, vlan_id="10"))
        self.run_task(d, "svi", vlan_id="10", vlan_name="USERS")
        self.assertIn("10", self.opts("svi_vlan", [d]))
        self.assertEqual(self.warns("gateway_redundancy", d, vlan_id="10"), [])
        self.assertIn("Vlan10", self.opts("iface", [d]))

    def test_junos_vlans_zones_addresses_policies(self):
        d = self.add("FW", "10.1.0.4", "juniper_srx", "srx300")
        self.eng.backup_device(d)
        self.assertEqual(sorted(self.opts("zone", [d])), ["trust", "untrust"])        # zone có sẵn trong cấu hình gốc
        self.run_task(d, "srx_zone", zone_name="dmz", zone_ifaces="ge-0/0/2")
        self.run_task(d, "srx_address", addr_name="WEB1", addr_value="10.1.1.10/32", addr_set="SERVERS")
        self.run_task(d, "srx_app", app_name="TCP-8080", app_port="8080")
        self.run_task(d, "srx_policy", to_zone="dmz", policy_name="P-WEB", source="WEB1", destination="any", application="TCP-8080")
        self.assertIn("dmz", self.opts("zone", [d]))
        self.assertIn("WEB1", self.opts("address", [d]))
        self.assertIn("SERVERS", self.opts("address", [d]))
        self.assertIn("any", self.opts("address", [d]))
        apps = self.opts("application", [d])
        self.assertIn("junos-https", apps)
        self.assertIn("TCP-8080", apps)
        self.assertIn("P-WEB", self.opts("policy", [d]))
        from core.config_facts import options_for
        pol = next(o for o in options_for("policy", [d], self.facts) if o.value == "P-WEB")
        self.assertEqual(dict(pol.extra), {"from_zone": "trust", "to_zone": "dmz"})   # chọn policy tự điền zone
        # cảnh báo tham chiếu chưa có
        w = self.warns("srx_policy", d, to_zone="vpn", source="NOPE", application="MY-APP", policy_name="NEW")
        self.assertTrue(any("zone 'vpn'" in x for x in w) and any("NOPE" in x for x in w) and any("MY-APP" in x for x in w), w)
        self.assertEqual(self.warns("srx_policy", d, to_zone="dmz", source="10.1.1.0/24", application="junos-http", policy_name="NEW2"), [])
        self.assertTrue(any("ĐÃ tồn tại" in x for x in self.warns("srx_policy", d, to_zone="dmz", policy_name="P-WEB", source="any")))
        self.assertEqual(self.warns("srx_policy_delete", d, from_zone="trust", to_zone="dmz", policy_name="P-WEB"), [])
        self.assertTrue(self.warns("srx_policy_delete", d, from_zone="trust", to_zone="dmz", policy_name="KHONG-CO"))

    def test_junos_switch_and_mikrotik_and_huawei(self):
        j = self.add("EX", "10.1.0.5", "juniper_junos", "ex4300-48t")
        self.eng.backup_device(j)
        self.run_task(j, "vlan", vlan_id="30", vlan_name="GUEST")
        self.assertEqual(self.opts("vlan", [j])["30"], "30 — GUEST")
        self.assertIn("ge-0/0/1", self.opts("port", [j]))
        self.assertEqual([x for x in self.warns("port_access", j, vlan_id="30", ports="ge-0/0/9") if "cổng" in x], [])   # Junos: không cảnh báo tên cổng
        m = self.add("MK", "10.1.0.6", "mikrotik_routeros")
        self.eng.backup_device(m)
        self.assertIn("bridge", self.opts("bridge", [m]))
        self.run_task(m, "vlan", vlan_id="40", vlan_name="IOT")
        self.assertIn("40", self.opts("vlan", [m]))
        h = self.add("HW", "10.1.0.7", "huawei")
        self.eng.backup_device(h)
        self.run_task(h, "vlan", vlan_id="50", vlan_name="VOICE")
        self.assertEqual(self.opts("vlan", [h])["50"], "50 — VOICE")
        self.assertIn("GigabitEthernet0/0/2", self.opts("port", [h]))

    def test_multiple_devices_union_with_availability(self):
        a, b = self.add("A", "10.1.0.8", "cisco_ios"), self.add("B", "10.1.0.9", "cisco_ios")
        for d in (a, b):
            self.eng.backup_device(d)
        self.run_task(a, "vlan", vlan_id="30", vlan_name="GUEST")
        o = self.opts("vlan", [a, b])
        self.assertIn("[1/2 thiết bị]", o["30"])
        self.assertNotIn("[", o["1"])

    def test_no_data_means_no_warnings_and_empty_options(self):
        d = self.add("NEW", "10.1.0.10", "cisco_ios")                         # chưa có bản sao lưu nào
        self.assertEqual(self.opts("vlan", [d]), {})
        self.assertEqual(self.warns("port_access", d, vlan_id="999"), [])


class TestShowCommands(unittest.TestCase):
    """Tab Công cụ: lệnh xem cấu hình theo hãng chạy được trên thiết bị giả lập."""

    def setUp(self):
        self.home, self.db, self.vault, self.eng, self.cat = make_env()

    def add(self, key, n):
        self.db.add_device(name=f"S{n}", ip=f"10.8.0.{n}", vendor=key, simulated=1, model="m1")
        return self.db.find_device_by_ip(f"10.8.0.{n}")

    def test_every_preset_is_read_only_and_simulated(self):
        from drivers.show_presets import config_command, presets_for
        from drivers.vendors import VENDORS
        total = 0
        for n, key in enumerate([k for k in VENDORS if k != "mock"], start=1):
            d = self.add(key, n)
            pres = presets_for(key)
            self.assertEqual(pres[0][1], config_command(key))
            for label, cmd in pres:
                total += 1
                self.assertTrue(is_read_only_command(cmd), f"{key}: '{cmd}' phải là lệnh chỉ đọc")
                out = self.eng.run_show(d, cmd)
                self.assertTrue(out.strip(), f"{key}: '{cmd}' trả về rỗng")
                self.assertNotIn("chưa được mô phỏng", out, f"{key}: '{cmd}'")
        self.assertGreater(total, 80)

    def test_config_command_per_family(self):
        from drivers.show_presets import config_command
        self.assertEqual(config_command("cisco_ios"), "show running-config")
        self.assertEqual(config_command("hp_comware"), "display current-configuration")
        self.assertEqual(config_command("huawei"), "display current-configuration")
        self.assertIn("display set", config_command("juniper_junos"))
        self.assertEqual(config_command("mikrotik_routeros"), "/export")
        self.assertEqual(config_command("openwrt"), "uci export")
        self.assertEqual(config_command("fortinet"), "show full-configuration")

    def test_output_reflects_real_changes_and_pipes(self):
        from tests.sample_vars import variables
        d = self.add("cisco_ios", 1)
        v = variables("svi")
        self.eng.run_job([d], lambda dev, i: self.cat.render("svi", dev, v, i), "svi", dry_run=False, workers=1)
        out = self.eng.run_show(d, "show ip interface brief")
        self.assertIn("Vlan10", out)
        self.assertIn("10.10.10.2", out)
        self.assertIn("interface Vlan10", self.eng.run_show(d, "show running-config | section Vlan10"))
        only = self.eng.run_show(d, "show running-config | include hostname")
        self.assertEqual(only.strip().split("\n"), ["hostname S1"])
        self.assertTrue(self.eng.run_show(d, "show running-config | count").startswith("Count:"))
        self.assertIn("vlan", self.eng.run_show(d, "sh vlan brief").lower())

    def test_srx_policy_visible_after_creation(self):
        from tests.sample_vars import variables
        d = self.add("juniper_srx", 2)
        for task, kw in (("srx_zone", dict(zone_name="dmz")), ("srx_policy", dict(to_zone="dmz"))):
            vv = variables(task, **kw)
            _, res = self.eng.run_job([d], lambda dev, i, t=task, vv=vv: self.cat.render(t, dev, vv, i), task, dry_run=False, workers=1)
            self.assertEqual(res[0].status, "success", res[0].message)
        out = self.eng.run_show(d, "show security policies")
        self.assertIn("From zone: trust, To zone: dmz", out)
        self.assertIn("Policy: LAN-OUT, action-type: permit", out)
        self.assertIn("junos-http, junos-https", out)
        self.assertIn("ge-0/0/2.0", self.eng.run_show(d, "show security zones"))
        self.assertIn("security-zone dmz", self.eng.run_show(d, "show configuration security | match dmz"))

    def test_write_pipes_are_blocked(self):
        for bad in ("show running-config | save file.txt", "show configuration | display set > x", "show run | tee out.txt",
                    "reload", "show run; reload"):
            self.assertFalse(is_read_only_command(bad), bad)
        for good in ("show configuration | display set | no-more", "show run | section interface", "/export", "uci show wireless",
                     "show security policies", "get system status"):
            self.assertTrue(is_read_only_command(good), good)


class TestJuniperSRX(unittest.TestCase):
    """Juniper SRX là firewall: có zone, address book, security policy, NAT, route tĩnh."""

    def setUp(self):
        self.home, self.db, self.vault, self.eng, self.cat = make_env()

    def add(self, name, ip, vendor="juniper_srx", model="srx300"):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1, model=model)
        return self.db.find_device_by_ip(ip)

    def run_task(self, d, task, **kw):
        from tests.sample_vars import variables
        v = variables(task, **kw)
        _, res = self.eng.run_job([d], lambda dev, i: self.cat.render(task, dev, v, i), task, dry_run=False, workers=1)
        return res[0]

    def test_task_support_split_between_srx_and_switch(self):
        srx_tasks = ["srx_zone", "srx_address", "srx_app", "srx_policy", "srx_policy_delete", "srx_nat_source", "srx_nat_dest",
                     "static_route", "l3_port", "ospf", "hostname", "snmp_v3"]
        for t in srx_tasks:
            self.assertTrue(self.cat.supported(t, "juniper_srx"), t)
        for t in ("vlan", "port_access", "port_trunk", "stp", "lacp", "dhcp_snooping", "svi"):
            self.assertFalse(self.cat.supported(t, "juniper_srx"), f"{t} không dành cho SRX")
        for t in srx_tasks[:7]:
            self.assertFalse(self.cat.supported(t, "juniper_junos"), f"{t} chỉ dành cho SRX")
        self.assertFalse(self.cat.supported("srx_policy", "cisco_ios"))

    def test_policy_commands(self):
        from tests.sample_vars import variables
        dev = {"name": "FW", "ip": "1.1.1.1", "site": "x", "vendor": "juniper_srx"}
        out = self.cat.render("srx_policy", dev, variables("srx_policy"))
        self.assertIn("set security address-book global address N_10.1.1.0_24 10.1.1.0/24", out)
        self.assertIn("set security policies from-zone trust to-zone untrust policy LAN-OUT match application [ junos-http junos-https ]", out)
        self.assertIn("set security policies from-zone trust to-zone untrust policy LAN-OUT then permit", out)
        out = self.cat.render("srx_policy", dev, variables("srx_policy", source="WEB1", destination="203.0.113.9", log=False))
        self.assertTrue(any(ln.endswith("match source-address WEB1") for ln in out))   # tên có sẵn: không tạo address mới
        self.assertFalse(any("address WEB1 " in ln for ln in out))
        self.assertIn("set security address-book global address H_203.0.113.9 203.0.113.9/32", out)
        self.assertFalse(any("then log" in ln for ln in out))
        with self.assertRaises(TemplateError):
            self.cat.render("srx_policy", dev, variables("srx_policy", source="10.1.1.999/24"))
        with self.assertRaises(TemplateError):
            self.cat.render("srx_nat_source", dev, variables("srx_nat_source", ns_mode="pool"))     # thiếu pool
        nat = self.cat.render("srx_nat_dest", dev, variables("srx_nat_dest"))
        self.assertIn("set security nat destination pool WEB-POOL address 10.1.1.10/32 port 8443", nat)

    def test_simulated_srx_validates_references_like_a_firewall(self):
        d = self.add("FW-SIM", "10.55.0.1")
        r = self.run_task(d, "srx_policy", to_zone="dmz")                # zone dmz chưa tồn tại
        self.assertEqual(r.status, "warning", r.message)
        self.assertIn("dmz", r.output)
        key = MockDriver.key_for(d["ip"], "juniper_srx")
        self.assertFalse(any("LAN-OUT" in ln for ln in MockDriver.STORE[key]), "lỗi thì không được commit")
        self.assertEqual(self.run_task(d, "srx_zone").status, "success")               # tạo zone dmz
        self.assertEqual(self.run_task(d, "srx_policy", to_zone="dmz").status, "success")
        r = self.run_task(d, "srx_policy", policy_name="P2", application="MY-APP", to_zone="dmz")
        self.assertEqual(r.status, "warning")                                           # application tùy chỉnh chưa tạo
        self.assertEqual(self.run_task(d, "srx_app", app_name="MY-APP").status, "success")
        self.assertEqual(self.run_task(d, "srx_policy", policy_name="P2", application="MY-APP", to_zone="dmz").status, "success")

    def test_srx_end_to_end_and_rollback(self):
        d = self.add("FW-RB", "10.56.0.1")
        for task in ("srx_zone", "srx_address", "srx_app", "srx_nat_source", "srx_nat_dest"):
            r = self.run_task(d, task)
            self.assertEqual(r.status, "success", f"{task}: {r.message}")
        r = self.run_task(d, "static_route", dest="10.200.0.0/16", next_hop="192.168.1.254")
        self.assertEqual(r.status, "success", r.message)
        cfg = "\n".join(MockDriver.STORE[MockDriver.key_for(d["ip"], "juniper_srx")])
        self.assertIn("set routing-options static route 10.200.0.0/16 next-hop 192.168.1.254", cfg)
        first = self.db.list_backups(d["id"])[-1]["id"]
        cmds, _, _ = self.eng.preview_rollback(d, first)
        self.assertTrue(any(c.startswith("delete security") for c in cmds))
        self.assertEqual(self.eng.rollback(d, first, cmds).status, "success")
        cfg = "\n".join(MockDriver.STORE[MockDriver.key_for(d["ip"], "juniper_srx")])
        self.assertNotIn("10.200.0.0/16", cfg)
        self.assertNotIn("DNAT", cfg)

    def test_srx_is_separate_in_catalog_and_sample(self):
        from core.templating import sample_for
        from drivers.sim_catalog import build_choices
        srx = [c for c in build_choices() if c.simulated and c.vendor == "juniper_srx"]
        self.assertGreaterEqual(len(srx), 4)
        self.assertFalse(any(c.vendor == "juniper_junos" and "SRX" in c.label for c in build_choices() if c.simulated))
        self.assertIn("security zones", sample_for(["junos_srx"]))

    def test_old_srx_in_junos_vendor_migrates(self):
        p = self.home / "old2.db"
        db = Database(p)
        db.add_device(name="OLDSRX", ip="2.2.2.2", vendor="juniper_junos", simulated=1, model="srx300")
        db.close()
        self.assertEqual(Database(p).find_device_by_ip("2.2.2.2")["vendor"], "juniper_srx")


class TestSimCatalog(unittest.TestCase):
    def test_merged_list_has_real_and_simulated_incl_juniper(self):
        from drivers.sim_catalog import HEADER_REAL, HEADER_SIM, build_choices, filter_choices, find_choice
        ch = build_choices()
        labels = [c.label for c in ch]
        self.assertLess(labels.index(HEADER_REAL), labels.index(HEADER_SIM))
        sims = [c for c in ch if c.simulated]
        self.assertGreaterEqual(len(sims), 30)
        jun = [c for c in sims if c.vendor == "juniper_junos"]
        self.assertGreaterEqual(len(jun), 4)
        self.assertTrue(any("EX4300" in c.label for c in jun) and any("QFX" in c.label for c in jun))
        self.assertTrue(all(c.model for c in sims))
        # mọi hãng thật (trừ mock) đều có ít nhất một thiết bị giả lập để chọn
        from drivers.vendors import VENDORS
        covered = {c.vendor for c in sims}
        self.assertTrue({k for k in VENDORS if k != "mock"} <= covered | {"cisco_asa"}, {k for k in VENDORS if k not in covered})
        # lọc theo từ khóa
        found = [c for c in filter_choices(ch, "junip") if not c.header]
        self.assertTrue(found and all("juniper" in (c.label + c.vendor).lower() for c in found))
        # sửa thiết bị: tìm đúng mục theo hãng + cờ giả lập + model
        c = find_choice(ch, "juniper_junos", True, "qfx5100-48s")
        self.assertTrue(c.simulated and c.model == "qfx5100-48s")
        self.assertFalse(find_choice(ch, "juniper_junos", False).simulated)

    def test_model_reaches_simulated_device(self):
        home, db, vault, eng, cat = make_env()
        db.add_device(name="J1", ip="10.20.0.1", vendor="juniper_junos", simulated=1, model="ex2300-24t")
        d = db.find_device_by_ip("10.20.0.1")
        text = eng.run_show(d, "show version")
        self.assertIn("ex2300-24t", text)
        self.assertIn("Junos", text)
        db.add_device(name="C1", ip="10.20.0.2", vendor="cisco_ios", simulated=1, model="WS-C2960X-48TS-L")
        self.assertIn("WS-C2960X-48TS-L", eng.run_show(db.find_device_by_ip("10.20.0.2"), "show version"))


class TestAdaptiveForms(unittest.TestCase):
    """Cấu hình thích ứng theo thiết bị: field chỉ hiện đúng họ thiết bị, mẫu lệnh tùy chỉnh theo hãng."""

    def setUp(self):
        self.cat = TaskCatalog(ROOT, Path(tempfile.mkdtemp()))

    def names(self, task, fams):
        return [f["name"] for f in self.cat.fields_for(task, fams)]

    def test_fields_filtered_by_family(self):
        self.assertIn("bridge", self.names("vlan", ["mikrotik"]))
        self.assertNotIn("bridge", self.names("vlan", ["ios"]))
        self.assertNotIn("bridge", self.names("port_trunk", ["junos"]))
        self.assertIn("helper", self.names("svi", ["ios"]))
        self.assertNotIn("helper", self.names("svi", ["junos"]))
        self.assertIn("vlan_name", self.names("svi", ["junos"]))
        self.assertIn("tz_olson", self.names("timezone", ["junos"]))
        self.assertNotIn("tz_olson", self.names("timezone", ["ios"]))
        self.assertIn("encap", self.names("port_trunk", ["ios"]))
        self.assertNotIn("encap", self.names("port_trunk", ["nxos"]))
        # chọn nhiều hãng -> hiện hợp của các trường
        self.assertTrue({"helper", "vlan_name"} <= set(self.names("svi", ["ios", "junos"])))
        # chưa chọn thiết bị -> hiện tất cả
        self.assertEqual(len(self.names("svi", [])), len(self.cat.fields("svi")))

    def test_required_fields_never_hidden(self):
        for tid in self.cat.task_ids():
            for fams in (["ios"], ["junos"], ["mikrotik"], ["huawei"]):
                shown = {f["name"] for f in self.cat.fields_for(tid, fams)}
                for f in self.cat.fields(tid):
                    if f.get("required"):
                        self.assertIn(f["name"], shown, f"{tid}.{f['name']} bắt buộc nhưng bị ẩn với {fams}")

    def test_hidden_fields_do_not_break_render(self):
        """Form chỉ gửi các trường hiển thị; trường của hãng khác không được làm lỗi hay đòi nhập."""
        dev = {"name": "R1", "ip": "1.1.1.1", "site": "x", "vendor": "juniper_junos"}
        out = self.cat.render("svi", dev, {"vlan_id": "10", "ip_cidr": "10.0.0.1/24"})
        self.assertIn("set interfaces irb unit 10 family inet address 10.0.0.1/24", out)
        out = self.cat.render("vlan", dict(dev, vendor="cisco_ios"), {"vlan_id": "10"})
        self.assertEqual(out, ["vlan 10", "exit"])

    def test_custom_sample_matches_vendor(self):
        from core.templating import sample_for
        self.assertIn("set system host-name", sample_for(["junos"]))
        self.assertIn("hostname", sample_for(["ios"]))
        self.assertIn("/system identity", sample_for(["mikrotik"]))
        mixed = sample_for(["ios", "junos"])
        self.assertIn("device.vendor.startswith", mixed)
        for fam, text in {"junos": sample_for(["junos"]), "ios": sample_for(["ios"]), "mixed": mixed}.items():
            out = self.cat.render_custom(text, {"name": "SW1", "ip": "1.1.1.1", "site": "HN", "vendor": "juniper_junos"})
            self.assertTrue(out or fam != "junos", fam)


class TestSimulators(unittest.TestCase):
    """Thiết bị giả lập theo từng hãng: áp dụng tác vụ, báo lỗi đúng kiểu hãng, rollback."""

    def setUp(self):
        self.home, self.db, self.vault, self.eng, self.cat = make_env()

    def add(self, name, ip, vendor):
        self.db.add_device(name=name, ip=ip, vendor=vendor, simulated=1)
        return self.db.find_device_by_ip(ip)

    def run_task(self, d, task, **kw):
        from tests.sample_vars import variables
        v = variables(task, **kw)
        _, res = self.eng.run_job([d], lambda dev, i: self.cat.render(task, dev, v, i), task, dry_run=False, workers=1)
        return res[0]

    def test_each_vendor_hostname_and_vlan(self):
        from drivers.vendors import VENDORS
        n = 0
        for key, v in VENDORS.items():
            if key == "mock":
                continue
            d = self.add(f"SIM-{key}", f"10.50.0.{n + 1}", key)
            n += 1
            ran = False
            for task in ("hostname", "vlan"):
                if self.cat.supported(task, key):
                    r = self.run_task(d, task, hostname="NEWNAME", vlan_id="30", vlan_name="GUEST")
                    self.assertEqual(r.status, "success", f"{key}/{task}: {r.message}")
                    ran = True
            if ran:
                self.assertTrue(self.db.last_backup(d["id"])["config"].strip())

    def test_junos_set_format_and_error(self):
        d = self.add("JUN1", "10.60.0.1", "juniper_junos")
        r = self.run_task(d, "svi", vlan_id="10", vlan_name="USERS")
        self.assertEqual(r.status, "success", r.message)
        cfg = MockDriver.STORE[MockDriver.key_for(d["ip"], "juniper_junos")]
        self.assertIn("set interfaces irb unit 10 family inet address 10.10.10.2/24", cfg)
        # lệnh sai kiểu Cisco gửi cho Junos -> lỗi, cấu hình không đổi (giống commit thất bại)
        before = list(cfg)
        _, res = self.eng.run_job([d], lambda dev, i: ["hostname X"], "sai", dry_run=False, workers=1)
        self.assertEqual(res[0].status, "warning")
        self.assertEqual(MockDriver.STORE[MockDriver.key_for(d["ip"], "juniper_junos")], before)

    def test_rollback_on_junos_huawei_nxos_aruba(self):
        cases = [("juniper_junos", "vlan", {}), ("huawei", "vlan", {}), ("cisco_nxos", "svi", {}),
                 ("aruba_os", "vlan", {}), ("hp_comware", "vlan", {}), ("cisco_ios", "static_route", {})]
        for n, (vendor, task, kw) in enumerate(cases, start=1):
            d = self.add(f"RB-{vendor}", f"10.70.{n}.1", vendor)
            r = self.run_task(d, task, **kw)
            self.assertEqual(r.status, "success", f"{vendor}: {r.message}")
            cmds, _, _ = self.eng.preview_rollback(d, r.backup_before)
            self.assertTrue(cmds, vendor)
            self.assertEqual(self.eng.rollback(d, r.backup_before, cmds).status, "success", vendor)
            self.assertEqual(ct.config_hash(MockDriver(self.eng.conn_params(d)).sim.show_config(
                MockDriver.STORE[MockDriver.key_for(d["ip"], vendor)])), ct.config_hash(self.db.get_backup(r.backup_before)["config"]),
                f"{vendor}: cấu hình sau rollback khác bản gốc")

    def test_huawei_rejects_cisco_no_and_mikrotik_duplicates(self):
        h = self.add("HW1", "10.80.0.1", "huawei")
        _, res = self.eng.run_job([h], lambda dev, i: ["no vlan 5"], "x", dry_run=False, workers=1)
        self.assertEqual(res[0].status, "warning")
        m = self.add("MK-SIM", "10.80.0.2", "mikrotik_routeros")
        r1 = self.run_task(m, "vlan", vlan_id="30", vlan_name="A")
        r2 = self.run_task(m, "vlan", vlan_id="30", vlan_name="A")       # tạo trùng -> RouterOS báo đã tồn tại
        self.assertEqual((r1.status, r2.status), ("success", "warning"), (r1.message, r2.message))

    def test_state_persists_and_reset(self):
        d = self.add("P1", "10.90.0.1", "cisco_ios")
        self.run_task(d, "vlan", vlan_id="77", vlan_name="X")
        MockDriver.STORE.clear()
        MockDriver._loaded = False                     # giả lập khởi động lại ứng dụng: đọc lại từ file
        self.assertTrue(any("vlan 77" in ln for ln in MockDriver(self.eng.conn_params(d))._state()))
        self.eng.reset_simulated(d)
        self.assertFalse(any("vlan 77" in ln for ln in MockDriver(self.eng.conn_params(d))._state()))

    def test_old_mock_vendor_migrates(self):
        import sqlite3
        p = self.home / "old.db"
        db = Database(p)
        db.add_device(name="OLD", ip="1.2.3.4", vendor="mock")
        db.close()
        row = Database(p).find_device_by_ip("1.2.3.4")
        self.assertEqual((row["vendor"], row["simulated"]), ("cisco_ios", 1))


class TestMisc(unittest.TestCase):
    def test_read_only_commands(self):
        self.assertTrue(is_read_only_command("show version"))
        self.assertTrue(is_read_only_command("/interface print"))
        self.assertFalse(is_read_only_command("reload"))
        self.assertFalse(is_read_only_command("show run; reload"))
        self.assertFalse(is_read_only_command("configure terminal"))

    def test_scanner_targets_and_snmp(self):
        self.assertEqual(len(scanner.expand_targets("10.0.0.0/30")), 2)
        self.assertEqual(scanner.expand_targets("10.0.0.5-7"), ["10.0.0.5", "10.0.0.6", "10.0.0.7"])
        vb = scanner._tlv(0x30, scanner._oid(scanner.SYS_DESCR) + scanner._tlv(0x04, b"RouterOS RB750"))
        pdu = scanner._tlv(0xA2, scanner._int(1) + scanner._int(0) + scanner._int(0) + scanner._tlv(0x30, vb))
        resp = scanner._tlv(0x30, scanner._int(1) + scanner._tlv(0x04, b"public") + pdu)
        self.assertEqual(scanner.parse_snmp_response(resp), "RouterOS RB750")
        from drivers.vendors import guess_vendor, SNMP_HINTS
        self.assertEqual(guess_vendor("RouterOS RB750", SNMP_HINTS), "mikrotik_routeros")
        with self.assertRaises(ValueError):
            scanner.expand_targets("10.0.0.0/8")


if __name__ == "__main__":
    unittest.main(verbosity=2)
