Fix: all frontends must use the custom-frontend interface

Author: p-gentili

cert-tools/toolbox/src/toolbox/checkbox/installers/snaps.py

@@ -1,5 +1,6 @@
 """Checkbox installer for snap-based installations."""
 
+import contextlib
 import logging
 import os
 
@@ -105,33 +106,36 @@ def install_frontend_snap(self, snap: SnapSpecifier):
             strict = False
         return strict
 
-    def has_custom_frontend_connected(self, frontend: SnapSpecifier) -> bool:
-        """Check if custom-frontend interface is connected between runtime and frontend.
-
-        The runtime has the plug, the frontend has the slot.
+    def custom_frontend_interface(self) -> bool:
+        """
+        Check if ALL frontends have the custom-frontend interface connected.
         """
         snap_connection_data = self.device.interfaces[SnapdAPIClient].get(
             "connections", params={"select": "all"}
         )
-        try:
-            plug = next(
-                plug
-                for plug in snap_connection_data["plugs"]
-                if plug["snap"] == self.runtime.name
+
+        frontends = {f.name for f in self.frontends}
+        for plug in snap_connection_data.get("plugs", []):
+            if (
+                plug["snap"] == self.runtime.name
                 and plug["interface"] == "content"
                 and plug.get("attrs", {}).get("content") == "custom-frontend"
-            )
-            next(conn for conn in plug["connections"] if conn["snap"] == frontend.name)
-            logger.info(
-                "custom-frontend interface connected: %s -> %s",
-                self.runtime.name,
-                frontend.name,
-            )
-            return True
-        except (StopIteration, KeyError):
-            logger.info("custom-frontend interface not connected")
+            ):
+                custom_frontend_plug = plug
+                break
+        else:
+            logger.warning("Installed runtime doesn't provide a custom-frontend plug")
+            return False
+
+        for conn in custom_frontend_plug.get("connections", []):
+            with contextlib.suppress(KeyError):
+                frontends.remove(conn["snap"])
+
+        if frontends:
             return False
 
+        return True
+
     def configure_agent(self, agent: SnapSpecifier):
         """Configure checkbox snap agent."""
         logger.info("Configuring legacy agent: %s", agent.name)
@@ -192,13 +196,12 @@ def restart(self):
             policy=Linear(times=30, delay=10),
         )
 
-        frontend = self.frontends[0]
-        if self.has_custom_frontend_connected(frontend):
-            logger.info("Using new providers interface for %s", frontend.name)
+        if self.custom_frontend_interface():
+            logger.info("Using new providers interface with runtime agent")
             agent = self.runtime
         else:
-            logger.info("Using legacy interface for %s", frontend.name)
-            agent = frontend
+            logger.info("Using legacy interface with frontend agent")
+            agent = self.frontends[0]
 
         self.configure_agent(agent)
 

cert-tools/toolbox/tests/checkbox/installers/test_snaps.py

@@ -474,8 +474,8 @@ def test_perform_connections(self, mocker):
         ]
         assert len(connect_calls) == 2
 
-    def test_has_custom_frontend_connected_true(self, mocker):
-        """Test detection when custom-frontend interface is connected."""
+    def test_custom_frontend_interface_true(self, mocker):
+        """Test returns True when all frontends have custom-frontend connected."""
         device = TrivialDevice(
             interfaces=[
                 SnapdAPIClient(),
@@ -497,7 +497,10 @@ def test_has_custom_frontend_connected_true(self, mocker):
                             "snap": "checkbox22",
                             "interface": "content",
                             "attrs": {"content": "custom-frontend"},
-                            "connections": [{"snap": "checkbox"}],
+                            "connections": [
+                                {"snap": "checkbox"},
+                                {"snap": "checkbox-iiotg"},
+                            ],
                         }
                     ]
                 },
@@ -510,18 +513,71 @@ def test_has_custom_frontend_connected_true(self, mocker):
         )
 
         frontends = [
-            SnapSpecifier(name="checkbox", channel=Channel.from_string("22/stable"))
+            SnapSpecifier(name="checkbox", channel=Channel.from_string("22/stable")),
+            SnapSpecifier(
+                name="checkbox-iiotg", channel=Channel.from_string("22/stable")
+            ),
         ]
         installer = CheckboxSnapsInstaller(
             device, TrivialDevice(), frontends, mocker.Mock()
         )
 
-        result = installer.has_custom_frontend_connected(frontends[0])
+        result = installer.custom_frontend_interface()
 
         assert result is True
 
-    def test_has_custom_frontend_connected_false(self, mocker):
-        """Test detection when custom-frontend interface is not connected."""
+    def test_custom_frontend_interface_false_missing(self, mocker):
+        """Test returns False when some frontends lack custom-frontend interface."""
+        device = TrivialDevice(
+            interfaces=[
+                SnapdAPIClient(),
+                RebootInterface(),
+                SystemStatusInterface(),
+                SnapInterface(),
+            ]
+        )
+
+        mocker.patch.object(
+            device.interfaces[SnapdAPIClient],
+            "get",
+            side_effect=[
+                {"architecture": "amd64", "store": None},
+                [{"store": "branded"}],
+                {
+                    "plugs": [
+                        {
+                            "snap": "checkbox22",
+                            "interface": "content",
+                            "attrs": {"content": "custom-frontend"},
+                            "connections": [{"snap": "checkbox"}],
+                        }
+                    ]
+                },
+            ],
+        )
+        mocker.patch(
+            "toolbox.checkbox.installers.snaps.CheckboxRuntimeHelper"
+        ).return_value.determine_checkbox_runtime.return_value = SnapSpecifier(
+            name="checkbox22", channel=Channel.from_string("latest/stable")
+        )
+
+        # Two frontends but only one is connected
+        frontends = [
+            SnapSpecifier(name="checkbox", channel=Channel.from_string("22/stable")),
+            SnapSpecifier(
+                name="checkbox-iiotg", channel=Channel.from_string("22/stable")
+            ),
+        ]
+        installer = CheckboxSnapsInstaller(
+            device, TrivialDevice(), frontends, mocker.Mock()
+        )
+
+        result = installer.custom_frontend_interface()
+
+        assert result is False
+
+    def test_custom_frontend_interface_false_no_plugs(self, mocker):
+        """Test returns False when no custom-frontend plugs exist."""
         device = TrivialDevice(
             interfaces=[
                 SnapdAPIClient(),
@@ -553,7 +609,7 @@ def test_has_custom_frontend_connected_false(self, mocker):
             device, TrivialDevice(), frontends, mocker.Mock()
         )
 
-        result = installer.has_custom_frontend_connected(frontends[0])
+        result = installer.custom_frontend_interface()
 
         assert result is False
 
@@ -634,9 +690,7 @@ def test_restart_new_interface(self, mocker):
             device, TrivialDevice(), frontends, mocker.Mock()
         )
 
-        mocker.patch.object(
-            installer, "has_custom_frontend_connected", return_value=True
-        )
+        mocker.patch.object(installer, "custom_frontend_interface", return_value=True)
         mock_configure_agent = mocker.patch.object(installer, "configure_agent")
 
         installer.restart()
@@ -688,9 +742,7 @@ def test_restart_legacy_interface(self, mocker):
             device, TrivialDevice(), frontends, mocker.Mock()
         )
 
-        mocker.patch.object(
-            installer, "has_custom_frontend_connected", return_value=False
-        )
+        mocker.patch.object(installer, "custom_frontend_interface", return_value=False)
         mock_configure_agent = mocker.patch.object(installer, "configure_agent")
 
         installer.restart()