Protect members of CoreLocalBackupAgent

homeassistant/components/backup/backup.py

@@ -44,21 +44,21 @@ def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the backup agent."""
         super().__init__()
         self._hass = hass
-        self.backup_dir = Path(hass.config.path("backups"))
-        self.backups: dict[str, LocalBackup] = {}
-        self.loaded_backups = False
+        self._backup_dir = Path(hass.config.path("backups"))
+        self._backups: dict[str, LocalBackup] = {}
+        self._loaded_backups = False
 
     async def load_backups(self) -> None:
         """Load data of stored backup files."""
         backups = await self._hass.async_add_executor_job(self._read_backups)
         LOGGER.debug("Loaded %s local backups", len(backups))
-        self.backups = backups
-        self.loaded_backups = True
+        self._backups = backups
+        self._loaded_backups = True
 
     def _read_backups(self) -> dict[str, LocalBackup]:
         """Read backups from disk."""
         backups: dict[str, LocalBackup] = {}
-        for backup_path in self.backup_dir.glob("*.tar"):
+        for backup_path in self._backup_dir.glob("*.tar"):
             try:
                 base_backup = read_backup(backup_path)
                 backup = LocalBackup(
@@ -93,7 +93,7 @@ async def async_upload_backup(
         **kwargs: Any,
     ) -> None:
         """Upload a backup."""
-        self.backups[metadata.slug] = LocalBackup(
+        self._backups[metadata.slug] = LocalBackup(
             id=metadata.slug,  # Do we need another ID?
             slug=metadata.slug,
             name=metadata.name,
@@ -105,18 +105,18 @@ async def async_upload_backup(
 
     async def async_list_backups(self, **kwargs: Any) -> list[UploadedBackup]:
         """List backups."""
-        if not self.loaded_backups:
+        if not self._loaded_backups:
             await self.load_backups()
-        return list(self.backups.values())
+        return list(self._backups.values())
 
     async def async_get_backup(
         self, *, slug: str, **kwargs: Any
     ) -> UploadedBackup | None:
         """Return a backup."""
-        if not self.loaded_backups:
+        if not self._loaded_backups:
             await self.load_backups()
 
-        if not (backup := self.backups.get(slug)):
+        if not (backup := self._backups.get(slug)):
             return None
 
         if not backup.path.exists():
@@ -128,14 +128,14 @@ async def async_get_backup(
                 backup.slug,
                 backup.path,
             )
-            self.backups.pop(slug)
+            self._backups.pop(slug)
             return None
 
         return backup
 
     def get_backup_path(self, slug: str) -> Path:
         """Return the local path to a backup."""
-        return self.backup_dir / f"{slug}.tar"
+        return self._backup_dir / f"{slug}.tar"
 
     async def async_remove_backup(self, *, slug: str, **kwargs: Any) -> None:
         """Remove a backup."""
@@ -144,4 +144,4 @@ async def async_remove_backup(self, *, slug: str, **kwargs: Any) -> None:
 
         await self._hass.async_add_executor_job(backup.path.unlink, True)  # type: ignore[attr-defined]
         LOGGER.debug("Removed backup located at %s", backup.path)  # type: ignore[attr-defined]
-        self.backups.pop(slug)
+        self._backups.pop(slug)

tests/components/backup/common.py

@@ -99,7 +99,7 @@ async def setup_backup_integration(
             return result
 
         local_agent = hass.data[DATA_MANAGER].backup_agents[LOCAL_AGENT_ID]
-        local_agent.backups = {backups.slug: backups for backups in backups}
-        local_agent.loaded_backups = True
+        local_agent._backups = {backups.slug: backups for backups in backups}
+        local_agent._loaded_backups = True
 
         return result

tests/components/backup/test_manager.py

@@ -90,7 +90,7 @@ def on_progress(_progress: BackupProgress) -> None:
         "type": "partial",
     }
     local_agent = manager.backup_agents[LOCAL_AGENT_ID]
-    assert local_agent.backup_dir.as_posix() in str(
+    assert local_agent._backup_dir.as_posix() in str(
         mocked_tarfile.call_args_list[0][0][0]
     )
     outer_tar = mocked_tarfile.return_value
@@ -180,8 +180,8 @@ async def test_removing_backup(
     await manager.load_platforms()
 
     local_agent = manager.backup_agents[LOCAL_AGENT_ID]
-    local_agent.backups = {TEST_LOCAL_BACKUP.slug: TEST_LOCAL_BACKUP}
-    local_agent.loaded_backups = True
+    local_agent._backups = {TEST_LOCAL_BACKUP.slug: TEST_LOCAL_BACKUP}
+    local_agent._loaded_backups = True
 
     with patch("pathlib.Path.exists", return_value=True):
         await manager.async_remove_backup(slug=TEST_LOCAL_BACKUP.slug)
@@ -214,8 +214,8 @@ async def test_getting_backup_that_does_not_exist(
     await manager.load_platforms()
 
     local_agent = manager.backup_agents[LOCAL_AGENT_ID]
-    local_agent.backups = {TEST_LOCAL_BACKUP.slug: TEST_LOCAL_BACKUP}
-    local_agent.loaded_backups = True
+    local_agent._backups = {TEST_LOCAL_BACKUP.slug: TEST_LOCAL_BACKUP}
+    local_agent._loaded_backups = True
 
     with patch("pathlib.Path.exists", return_value=False):
         backup = await manager.async_get_backup(slug=TEST_LOCAL_BACKUP.slug)
@@ -269,7 +269,7 @@ async def test_async_create_backup(
     await manager.load_platforms()
 
     local_agent = manager.backup_agents[LOCAL_AGENT_ID]
-    local_agent.loaded_backups = True
+    local_agent._loaded_backups = True
 
     await _mock_backup_generation(
         hass, manager, mocked_json_bytes, mocked_tarfile, **params
@@ -280,8 +280,8 @@ async def test_async_create_backup(
     assert "Loaded 0 platforms" in caplog.text
     assert "Loaded 1 agents" in caplog.text
 
-    assert len(local_agent.backups) == 1
-    backup = list(local_agent.backups.values())[0]
+    assert len(local_agent._backups) == 1
+    backup = list(local_agent._backups.values())[0]
     assert backup.protected is bool(params.get("password"))