first commit

netbox_librenms_plugin/tests/test_integration_virtual_chassis.py

@@ -0,0 +1,854 @@
+"""
+Integration tests for Virtual Chassis detection using the mock LibreNMS HTTP server.
+
+These tests verify that detect_virtual_chassis_from_inventory(), get_virtual_chassis_data(),
+and prefetch_vc_data_for_devices() work correctly end-to-end through real HTTP calls
+to a local mock server — no mocking of the detection logic itself.
+
+Run:
+    python -m pytest netbox_librenms_plugin/tests/test_integration_virtual_chassis.py -v
+"""
+
+import pytest
+from unittest.mock import patch
+
+from netbox_librenms_plugin.tests.mock_librenms_server import librenms_mock_server
+
+
+@pytest.fixture
+def mock_server():
+    with librenms_mock_server() as server:
+        yield server
+
+
+def _make_api(url, token="test-token", server_key="test"):
+    """Create a LibreNMSAPI instance pointed at the mock server."""
+    from netbox_librenms_plugin.librenms_api import LibreNMSAPI
+
+    servers_config = {
+        server_key: {
+            "librenms_url": url,
+            "api_token": token,
+            "cache_timeout": 300,
+            "verify_ssl": False,
+        }
+    }
+
+    with patch("netbox_librenms_plugin.librenms_api.get_plugin_config") as mock_cfg:
+        mock_cfg.side_effect = lambda _plugin, key: servers_config if key == "servers" else None
+        api = LibreNMSAPI(server_key=server_key)
+    return api
+
+
+def _chassis(index, serial, model="WS-C3750X", name="", descr="", position=None, contained_in=None):
+    """Build a minimal ENTITY-MIB chassis entry."""
+    item = {
+        "entPhysicalIndex": index,
+        "entPhysicalClass": "chassis",
+        "entPhysicalSerialNum": serial,
+        "entPhysicalModelName": model,
+        "entPhysicalName": name or f"Chassis-{index}",
+        "entPhysicalDescr": descr or f"Chassis {index}",
+    }
+    if position is not None:
+        item["entPhysicalParentRelPos"] = position
+    if contained_in is not None:
+        item["entPhysicalContainedIn"] = contained_in
+    return item
+
+
+def _stack_root(index=1):
+    """Build a 'stack' class root entry (e.g., Cisco StackWise)."""
+    return {
+        "entPhysicalIndex": index,
+        "entPhysicalClass": "stack",
+        "entPhysicalSerialNum": "",
+        "entPhysicalModelName": "",
+        "entPhysicalName": "StackSub-0/0",
+        "entPhysicalDescr": "Cisco StackWise",
+        "entPhysicalContainedIn": 0,
+    }
+
+
+class TestDetectVCCiscoStack:
+    """Cisco StackWise topology: root has stack-class entry; children are chassis members."""
+
+    def test_three_member_stack(self, mock_server):
+        """3 chassis members under a stack root → is_stack=True, member_count=3."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 10
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-stack", serial="MASTER")
+
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-A", position=1),
+            _chassis(200, "SN-B", position=2),
+            _chassis(300, "SN-C", position=3),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        assert result["is_stack"] is True
+        assert result["member_count"] == 3
+        serials = [m["serial"] for m in result["members"]]
+        assert serials == ["SN-A", "SN-B", "SN-C"]
+
+    def test_members_sorted_by_position(self, mock_server):
+        """Members returned in position order regardless of API order."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 11
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-stack-2")
+        root_items = [_stack_root(index=5)]
+        # Deliberately out of order: 3, 1, 2
+        member_items = [
+            _chassis(301, "SN-3", position=3),
+            _chassis(101, "SN-1", position=1),
+            _chassis(201, "SN-2", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {5: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        positions = [m["position"] for m in result["members"]]
+        assert positions == [1, 2, 3]
+
+    def test_position_zero_falls_back_to_idx_plus_one(self, mock_server):
+        """position=0 in entPhysicalParentRelPos → fallback to idx+1 (never 0)."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 12
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-stack-3")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-X", position=0),  # 0 → fallback to idx+1=1
+            _chassis(200, "SN-Y", position=0),  # 0 → fallback to idx+1=2
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        positions = [m["position"] for m in result["members"]]
+        # Both had position=0, so they fall back to idx+1: positions [1, 2]
+        assert all(p >= 1 for p in positions)
+
+    def test_member_fields_extracted_correctly(self, mock_server):
+        """serial, model, name, description all extracted from chassis entries."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 13
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-stack-4")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            {
+                "entPhysicalIndex": 100,
+                "entPhysicalClass": "chassis",
+                "entPhysicalSerialNum": "SERIAL-ABC",
+                "entPhysicalModelName": "WS-C3750X-48P",
+                "entPhysicalName": "Slot 1",
+                "entPhysicalDescr": "48-port PoE switch",
+                "entPhysicalParentRelPos": 1,
+            },
+            {
+                "entPhysicalIndex": 200,
+                "entPhysicalClass": "chassis",
+                "entPhysicalSerialNum": "SERIAL-DEF",
+                "entPhysicalModelName": "WS-C3750X-24T",
+                "entPhysicalName": "Slot 2",
+                "entPhysicalDescr": "24-port switch",
+                "entPhysicalParentRelPos": 2,
+            },
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        m1, m2 = result["members"]
+        assert m1["serial"] == "SERIAL-ABC"
+        assert m1["model"] == "WS-C3750X-48P"
+        assert m1["name"] == "Slot 1"
+        assert m1["description"] == "48-port PoE switch"
+        assert m2["serial"] == "SERIAL-DEF"
+
+    def test_suggested_name_uses_master_sysname(self, mock_server):
+        """suggested_name generated from master device sysName."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 14
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-master", serial="MASTER01")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-1", position=1),
+            _chassis(200, "SN-2", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        # Members should have non-empty suggested names
+        for member in result["members"]:
+            assert "suggested_name" in member
+            assert member["suggested_name"]  # non-empty
+
+
+class TestDetectVCJuniperStyle:
+    """Juniper-style: root has chassis-class entry; children are chassis members."""
+
+    def test_two_member_vc(self, mock_server):
+        """2 chassis members under a chassis root → is_stack=True, member_count=2."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 20
+
+        mock_server.device_info_response(device_id=device_id, hostname="vc-switch")
+        # Root: a chassis entry (not stack)
+        root_items = [
+            {
+                "entPhysicalIndex": 10,
+                "entPhysicalClass": "chassis",
+                "entPhysicalSerialNum": "",
+                "entPhysicalModelName": "",
+                "entPhysicalName": "Virtual Chassis",
+                "entPhysicalDescr": "EX4300 Virtual Chassis",
+                "entPhysicalContainedIn": 0,
+            }
+        ]
+        member_items = [
+            _chassis(100, "JN-SN-1", position=0),  # Juniper uses position=0,1 (1-based after fallback)
+            _chassis(200, "JN-SN-2", position=1),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {10: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        assert result["is_stack"] is True
+        assert result["member_count"] == 2
+
+
+class TestDetectVCStackPreferredOverChassis:
+    """When root has both stack and chassis entries, stack index takes priority."""
+
+    def test_stack_index_used_not_chassis(self, mock_server):
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 30
+
+        mock_server.device_info_response(device_id=device_id, hostname="sw-mixed")
+        # Root has BOTH stack (index=5) and chassis (index=6)
+        root_items = [
+            {
+                "entPhysicalIndex": 5,
+                "entPhysicalClass": "stack",
+                "entPhysicalName": "Stack-0",
+                "entPhysicalSerialNum": "",
+                "entPhysicalModelName": "",
+                "entPhysicalDescr": "",
+                "entPhysicalContainedIn": 0,
+            },
+            {
+                "entPhysicalIndex": 6,
+                "entPhysicalClass": "chassis",
+                "entPhysicalName": "Chassis-0",
+                "entPhysicalSerialNum": "",
+                "entPhysicalModelName": "",
+                "entPhysicalDescr": "",
+                "entPhysicalContainedIn": 0,
+            },
+        ]
+        # Stack index=5 has 2 members, chassis index=6 has 0
+        children = {
+            5: [_chassis(100, "SN-1", position=1), _chassis(200, "SN-2", position=2)],
+            6: [],  # chassis has no children
+        }
+        mock_server.vc_inventory_callable(device_id, root_items, children)
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        # Must have detected 2 members (via stack index), not 0 (via chassis index)
+        assert result is not None
+        assert result["member_count"] == 2
+
+
+class TestDetectVCSingleDevice:
+    """Non-stack device: only 1 chassis child → returns None."""
+
+    def test_single_chassis_child_returns_none(self, mock_server):
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 40
+
+        mock_server.device_info_response(device_id=device_id, hostname="single-sw")
+        root_items = [_stack_root(index=1)]
+        # Only 1 chassis child → not a VC
+        member_items = [_chassis(100, "SN-ONLY", position=1)]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is None
+
+    def test_no_stack_or_chassis_root_returns_none(self, mock_server):
+        """Root has only non-stack/chassis entries → returns None."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 41
+
+        mock_server.device_info_response(device_id=device_id, hostname="plain-router")
+        root_items = [
+            {
+                "entPhysicalIndex": 1,
+                "entPhysicalClass": "module",
+                "entPhysicalName": "Main Module",
+                "entPhysicalSerialNum": "SN1",
+                "entPhysicalModelName": "ASR1001-X",
+                "entPhysicalDescr": "ASR1001-X",
+                "entPhysicalContainedIn": 0,
+            }
+        ]
+        # Register root-only, no children needed
+        mock_server.vc_inventory_callable(device_id, root_items, {})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is None
+
+
+class TestDetectVCEdgeCases:
+    """API errors and empty responses."""
+
+    def test_empty_root_inventory_returns_none(self, mock_server):
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 50
+
+        mock_server.device_info_response(device_id=device_id, hostname="empty-sw")
+        mock_server.vc_inventory_callable(device_id, [], {})  # empty root
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is None
+
+    def test_api_error_on_root_returns_none(self, mock_server):
+        """500 error on root inventory → returns None."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 51
+
+        mock_server.device_info_response(device_id=device_id, hostname="error-sw")
+        # Register 500 for inventory calls
+        mock_server.register(f"/api/v0/inventory/{device_id}", {"status": "error"}, status=500)
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is None
+
+    def test_empty_serial_included_in_members(self, mock_server):
+        """Members with empty entPhysicalSerialNum are included, not skipped."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 52
+
+        mock_server.device_info_response(device_id=device_id, hostname="nosn-sw")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "", position=1),  # empty serial
+            _chassis(200, "SN-B", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        assert result is not None
+        assert result["member_count"] == 2
+        assert result["members"][0]["serial"] == ""  # empty is preserved
+
+    def test_device_info_failure_still_detects_vc(self, mock_server):
+        """get_device_info() returning False → detection still works, suggested_name uses fallback."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import detect_virtual_chassis_from_inventory
+
+        api = _make_api(mock_server.url)
+        device_id = 53
+
+        # No device_info registered → 404
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-1", position=1),
+            _chassis(200, "SN-2", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch(
+            "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+            return_value="{master}-m{position}",
+        ):
+            result = detect_virtual_chassis_from_inventory(api, device_id)
+
+        # Should still detect VC even without device info
+        assert result is not None
+        assert result["member_count"] == 2
+        # Without master name, suggested_name falls back to "Member-{position}"
+        for member in result["members"]:
+            assert member["suggested_name"].startswith("Member-")
+
+
+class TestGetVCDataHTTP:
+    """get_virtual_chassis_data() integrating with mock HTTP server and patched cache."""
+
+    def test_cache_miss_fetches_via_http(self, mock_server):
+        """Cache miss triggers detect_virtual_chassis_from_inventory via HTTP."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 60
+
+        mock_server.device_info_response(device_id=device_id, hostname="cached-sw")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-1", position=1),
+            _chassis(200, "SN-2", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.return_value = None  # cache miss
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                result = get_virtual_chassis_data(api, device_id)
+
+        # Should have called cache.set to store result
+        assert mock_cache.set.called
+        assert result is not None
+        assert result["is_stack"] is True
+        assert result["member_count"] == 2
+
+    def test_cache_hit_returns_without_http(self, mock_server):
+        """Cache hit returns immediately without making any HTTP calls."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 61
+
+        # Include detection_error to match what _clone_virtual_chassis_data adds
+        cached_data = {"is_stack": True, "member_count": 3, "members": [], "detection_error": None}
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.return_value = cached_data
+            result = get_virtual_chassis_data(api, device_id)
+
+        # cache.set should NOT be called (no new fetch)
+        assert not mock_cache.set.called
+        assert result["is_stack"] is True
+        assert result["member_count"] == 3
+
+    def test_force_refresh_fetches_even_if_cached(self, mock_server):
+        """force_refresh=True bypasses cache and fetches from HTTP."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 62
+
+        mock_server.device_info_response(device_id=device_id, hostname="refresh-sw")
+        root_items = [_stack_root(index=1)]
+        member_items = [
+            _chassis(100, "SN-A", position=1),
+            _chassis(200, "SN-B", position=2),
+        ]
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        # Even with cached data, force_refresh should hit the API
+        old_cached = {"is_stack": True, "member_count": 1, "members": [{"serial": "OLD"}], "detection_error": None}
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.return_value = old_cached
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                result = get_virtual_chassis_data(api, device_id, force_refresh=True)
+
+        # Should have fetched fresh data, not used old_cached
+        assert result is not None
+        assert result["member_count"] == 2  # new data, not old
+
+    def test_non_vc_device_returns_empty_dict(self, mock_server):
+        """Single device (not VC) → detect returns None → get_virtual_chassis_data returns empty."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 63
+
+        mock_server.device_info_response(device_id=device_id, hostname="single-sw")
+        root_items = [_stack_root(index=1)]
+        member_items = [_chassis(100, "SN-ONLY", position=1)]  # only 1 → not VC
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.return_value = None
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                result = get_virtual_chassis_data(api, device_id)
+
+        assert result is not None
+        assert result.get("is_stack") is False
+
+
+class TestPrefetchVCHTTP:
+    """prefetch_vc_data_for_devices() fetches multiple devices in batch."""
+
+    def test_prefetch_multiple_vc_devices(self, mock_server):
+        """Three VC devices → cache populated for all three."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import prefetch_vc_data_for_devices
+
+        api = _make_api(mock_server.url)
+
+        for dev_id, hostname in [(70, "sw-70"), (71, "sw-71"), (72, "sw-72")]:
+            mock_server.device_info_response(device_id=dev_id, hostname=hostname)
+            root_items = [_stack_root(index=1)]
+            member_items = [
+                _chassis(100, f"SN-{dev_id}-1", position=1),
+                _chassis(200, f"SN-{dev_id}-2", position=2),
+            ]
+            mock_server.vc_inventory_callable(dev_id, root_items, {1: member_items})
+
+        cache_store = {}
+
+        def mock_cache_set(key, val, timeout=None):
+            cache_store[key] = val
+
+        def mock_cache_get(key):
+            return cache_store.get(key)
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.side_effect = mock_cache_get
+            mock_cache.set.side_effect = mock_cache_set
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                prefetch_vc_data_for_devices(api, [70, 71, 72])
+
+        # Cache should have entries for all 3 VC devices
+        assert len(cache_store) >= 3
+
+    def test_prefetch_mix_vc_and_single(self, mock_server):
+        """Mix of VC and single devices → VC is cached, single is processed without error."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import prefetch_vc_data_for_devices
+
+        api = _make_api(mock_server.url)
+
+        # Device 80 = 2-member VC
+        mock_server.device_info_response(device_id=80, hostname="sw-stack")
+        root_items_80 = [_stack_root(index=1)]
+        member_items_80 = [_chassis(100, "SN-80-1", position=1), _chassis(200, "SN-80-2", position=2)]
+        mock_server.vc_inventory_callable(80, root_items_80, {1: member_items_80})
+
+        # Device 81 = single (no VC)
+        mock_server.device_info_response(device_id=81, hostname="sw-single")
+        root_items_81 = [_stack_root(index=1)]
+        member_items_81 = [_chassis(100, "SN-81", position=1)]  # only 1 → not VC
+        mock_server.vc_inventory_callable(81, root_items_81, {1: member_items_81})
+
+        cache_store = {}
+
+        def mock_cache_set(key, val, timeout=None):
+            cache_store[key] = val
+
+        def mock_cache_get(key):
+            return cache_store.get(key)
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.side_effect = mock_cache_get
+            mock_cache.set.side_effect = mock_cache_set
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                prefetch_vc_data_for_devices(api, [80, 81])
+
+        # Both the VC device (80) and the non-VC device (81) should be cached.
+        # Non-VC devices get an empty_virtual_chassis_data() cached so prefetch
+        # suppresses repeated API hits on subsequent renders.
+        assert len(cache_store) == 2
+
+
+class TestNegativeVCCaching:
+    """Negative results (non-stack, API errors) must be cached to suppress repeated hits."""
+
+    def test_non_vc_device_result_is_cached(self, mock_server):
+        """Single device (not a stack) → detect returns None → empty result cached."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 200
+
+        mock_server.device_info_response(device_id=device_id, hostname="single-sw")
+        root_items = [_stack_root(index=1)]
+        member_items = [_chassis(100, "SN-ONLY", position=1)]  # 1 chassis only → not VC
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        cache_store = {}
+
+        def mock_cache_set(key, val, timeout=None):
+            cache_store[key] = val
+
+        def mock_cache_get(key):
+            return cache_store.get(key)
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.side_effect = mock_cache_get
+            mock_cache.set.side_effect = mock_cache_set
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                result = get_virtual_chassis_data(api, device_id)
+
+        assert result is not None
+        assert result.get("is_stack") is False
+        assert result.get("member_count") == 0
+        # The empty result must have been written to cache so a second call is a hit.
+        assert len(cache_store) == 1
+        cached = list(cache_store.values())[0]
+        assert cached.get("is_stack") is False
+
+    def test_api_error_result_is_cached(self, mock_server):
+        """API 500 on inventory → detect returns None → empty result still cached."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 201
+
+        # Register a 500 for the root inventory call
+        mock_server.routes[f"/api/v0/inventory/{device_id}"] = (500, {"status": "error", "message": "internal"})
+
+        cache_store = {}
+
+        def mock_cache_set(key, val, timeout=None):
+            cache_store[key] = val
+
+        def mock_cache_get(key):
+            return cache_store.get(key)
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.side_effect = mock_cache_get
+            mock_cache.set.side_effect = mock_cache_set
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                result = get_virtual_chassis_data(api, device_id)
+
+        assert result is not None
+        assert result.get("is_stack") is False
+        # Even API failures get cached to suppress repeated hits until TTL expires.
+        assert len(cache_store) == 1
+
+    def test_force_refresh_bypasses_negative_cache(self, mock_server):
+        """force_refresh=True re-fetches even when a negative result is cached."""
+        from netbox_librenms_plugin.import_utils.virtual_chassis import get_virtual_chassis_data
+
+        api = _make_api(mock_server.url)
+        device_id = 202
+
+        mock_server.device_info_response(device_id=device_id, hostname="single-sw-202")
+        root_items = [_stack_root(index=1)]
+        member_items = [_chassis(100, "SN-202", position=1)]  # 1 chassis → not VC
+        mock_server.vc_inventory_callable(device_id, root_items, {1: member_items})
+
+        # Pre-populate cache with an empty (negative) result.
+        empty_cached = {"is_stack": False, "member_count": 0, "members": [], "detection_error": None}
+
+        call_count = {"n": 0}
+
+        def mock_cache_get(key):
+            return empty_cached  # always returns cached negative
+
+        cache_set_calls = []
+
+        def mock_cache_set(key, val, timeout=None):
+            cache_set_calls.append((key, val))
+            call_count["n"] += 1
+
+        with patch("netbox_librenms_plugin.import_utils.virtual_chassis.cache") as mock_cache:
+            mock_cache.get.side_effect = mock_cache_get
+            mock_cache.set.side_effect = mock_cache_set
+            with patch(
+                "netbox_librenms_plugin.import_utils.virtual_chassis._load_vc_member_name_pattern",
+                return_value="{master}-m{position}",
+            ):
+                # Normal call — should use cache, NOT call set again
+                result_cached = get_virtual_chassis_data(api, device_id)
+                assert call_count["n"] == 0  # no new set; cache hit returned
+
+                # force_refresh=True — must bypass cache and re-fetch + re-cache
+                result_fresh = get_virtual_chassis_data(api, device_id, force_refresh=True)
+                assert call_count["n"] == 1  # set called once for the re-fetch
+
+        assert result_cached.get("is_stack") is False
+        assert result_fresh.get("is_stack") is False
+
+
+class TestVCPortFetch:
+    """Port fetching for VC master: port names with VC member suffixes."""
+
+    def test_ports_with_vc_suffixes_returned_as_is(self, mock_server):
+        """Port names like Gi1/0/1 and Gi2/0/1 preserved from API response."""
+        api = _make_api(mock_server.url)
+
+        vc_ports = [
+            {
+                "port_id": 101,
+                "ifName": "GigabitEthernet1/0/1",
+                "ifDescr": "GigabitEthernet1/0/1",
+                "ifType": "ethernetCsmacd",
+                "ifSpeed": 1_000_000_000,
+                "ifAdminStatus": "up",
+                "ifAlias": "uplink-m1",
+                "ifPhysAddress": "aa:bb:cc:dd:ee:01",
+                "ifMtu": 1500,
+                "ifVlan": 1,
+                "ifTrunk": 0,
+            },
+            {
+                "port_id": 201,
+                "ifName": "GigabitEthernet2/0/1",
+                "ifDescr": "GigabitEthernet2/0/1",
+                "ifType": "ethernetCsmacd",
+                "ifSpeed": 1_000_000_000,
+                "ifAdminStatus": "up",
+                "ifAlias": "uplink-m2",
+                "ifPhysAddress": "aa:bb:cc:dd:ee:02",
+                "ifMtu": 1500,
+                "ifVlan": 1,
+                "ifTrunk": 0,
+            },
+            {
+                "port_id": 301,
+                "ifName": "GigabitEthernet1/0/2",
+                "ifDescr": "GigabitEthernet1/0/2",
+                "ifType": "ethernetCsmacd",
+                "ifSpeed": 1_000_000_000,
+                "ifAdminStatus": "down",
+                "ifAlias": "",
+                "ifPhysAddress": "aa:bb:cc:dd:ee:03",
+                "ifMtu": 1500,
+                "ifVlan": 10,
+                "ifTrunk": 0,
+            },
+        ]
+        mock_server.ports_response(device_id=90, ports=vc_ports)
+
+        ok, data = api.get_ports(90)
+
+        assert ok is True
+        names = [p["ifName"] for p in data["ports"]]
+        assert "GigabitEthernet1/0/1" in names
+        assert "GigabitEthernet2/0/1" in names
+        assert "GigabitEthernet1/0/2" in names
+
+    def test_all_port_fields_preserved(self, mock_server):
+        """ifName, ifDescr, ifAlias, ifSpeed all preserved from LibreNMS response."""
+        api = _make_api(mock_server.url)
+
+        ports_data = [
+            {
+                "port_id": 111,
+                "ifName": "GigabitEthernet1/0/1",
+                "ifDescr": "GigabitEthernet1/0/1",
+                "ifType": "ethernetCsmacd",
+                "ifSpeed": 1_000_000_000,
+                "ifAdminStatus": "up",
+                "ifAlias": "server-link",
+                "ifPhysAddress": "aa:bb:cc:00:00:01",
+                "ifMtu": 9000,
+                "ifVlan": 100,
+                "ifTrunk": 1,
+            },
+        ]
+        mock_server.ports_response(device_id=91, ports=ports_data)
+
+        ok, data = api.get_ports(91)
+
+        assert ok is True
+        port = data["ports"][0]
+        assert port["ifName"] == "GigabitEthernet1/0/1"
+        assert port["ifAlias"] == "server-link"
+        assert port["ifSpeed"] == 1_000_000_000
+        assert port["ifMtu"] == 9000