didericis-claude
2915706659
test / integration-docker (pull_request) Successful in 8s
tracker-policy-pr / check-pr (pull_request) Successful in 5s
test / unit (pull_request) Successful in 31s
lint / lint (push) Successful in 43s
test / stage-firecracker-inputs (pull_request) Successful in 5s
test / build-infra (pull_request) Successful in 3m37s
test / integration-firecracker (pull_request) Successful in 1m39s
test / coverage (pull_request) Successful in 2m1s
test / publish-infra (pull_request) Has been skipped
Replaces broad `except Exception` with specific types that reflect the actual failure modes: - _save_credentials: `except OSError` (IO-only path; re-raises for cleanup) - _post error handler: `except (OSError, ValueError)` (network + bad JSON) - poll-loop: `except (OSError, ValueError)` (network + bad JSON) Also: - Simplify _fake_get to use next(..., default) — removes uncovered StopIteration branch - Add encoding="utf-8" to open() in test_approved_flow_returns_0 - Add test_cleanup_on_write_failure to cover the except OSError block in _save_credentials All files score 10.00/10 on pylint (fail-under=10) and 0 errors on pyright strict.
269 lines
10 KiB
Python
269 lines
10 KiB
Python
"""Unit tests for bb login command."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import tempfile
|
|
import unittest
|
|
import urllib.error
|
|
from email.message import Message
|
|
from typing import Any
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
|
|
class TestFlagParsing(unittest.TestCase):
|
|
def test_console_url_flag(self) -> None:
|
|
from bot_bottle.cli.login import _flag
|
|
self.assertEqual(_flag(["--console-url", "http://x"], "--console-url"), "http://x")
|
|
|
|
def test_console_url_equals_form(self) -> None:
|
|
from bot_bottle.cli.login import _flag
|
|
self.assertEqual(
|
|
_flag(["--console-url=http://x"], "--console-url"), "http://x"
|
|
)
|
|
|
|
def test_label_flag(self) -> None:
|
|
from bot_bottle.cli.login import _flag
|
|
self.assertEqual(_flag(["--label", "my-mac"], "--label"), "my-mac")
|
|
|
|
def test_missing_flag_returns_none(self) -> None:
|
|
from bot_bottle.cli.login import _flag
|
|
self.assertIsNone(_flag([], "--console-url"))
|
|
|
|
|
|
class TestHttpHelpers(unittest.TestCase):
|
|
def test_post_sends_json_and_decodes_response(self) -> None:
|
|
from bot_bottle.cli.login import _post
|
|
|
|
response = MagicMock()
|
|
response.__enter__.return_value.read.return_value = b'{"ok": true}'
|
|
with patch("urllib.request.urlopen", return_value=response) as urlopen:
|
|
self.assertEqual(
|
|
_post("http://console/start", {"label": "host"}), {"ok": True}
|
|
)
|
|
|
|
request = urlopen.call_args.args[0]
|
|
self.assertEqual(request.data, b'{"label": "host"}')
|
|
self.assertEqual(request.get_header("Content-type"), "application/json")
|
|
|
|
def test_get_decodes_success_response(self) -> None:
|
|
from bot_bottle.cli.login import _get
|
|
|
|
response = MagicMock()
|
|
response.__enter__.return_value.status = 200
|
|
response.__enter__.return_value.read.return_value = b'{"status": "pending"}'
|
|
with patch("urllib.request.urlopen", return_value=response):
|
|
self.assertEqual(
|
|
_get("http://console/status"), (200, {"status": "pending"})
|
|
)
|
|
|
|
def test_get_returns_http_error_status(self) -> None:
|
|
from bot_bottle.cli.login import _get
|
|
|
|
error = urllib.error.HTTPError(
|
|
"http://console/status", 410, "gone", Message(), None
|
|
)
|
|
with patch("urllib.request.urlopen", side_effect=error):
|
|
self.assertEqual(_get("http://console/status"), (410, {}))
|
|
|
|
|
|
class TestSaveCredentials(unittest.TestCase):
|
|
def test_writes_json_and_sets_perms(self) -> None:
|
|
from bot_bottle.cli.login import _save_credentials
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
path = _save_credentials("http://c", "hid", "at", "rt")
|
|
self.assertTrue(path.exists())
|
|
data = json.loads(path.read_text())
|
|
self.assertEqual(data["url"], "http://c")
|
|
self.assertEqual(data["host_id"], "hid")
|
|
self.assertEqual(data["access_token"], "at")
|
|
self.assertEqual(data["refresh_token"], "rt")
|
|
self.assertEqual(oct(path.stat().st_mode & 0o777), oct(0o600))
|
|
|
|
def test_temp_file_is_private_before_replace(self) -> None:
|
|
"""Temp file must be 0600 at the moment os.replace is called."""
|
|
from bot_bottle.cli.login import _save_credentials
|
|
from pathlib import Path as _Path
|
|
|
|
tmp_perms_at_replace: list[int] = []
|
|
real_replace = os.replace
|
|
|
|
def _spy_replace(
|
|
src: str | os.PathLike[str], dst: str | os.PathLike[str]
|
|
) -> None:
|
|
tmp_perms_at_replace.append(_Path(src).stat().st_mode & 0o777)
|
|
real_replace(src, dst)
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
with patch("os.replace", side_effect=_spy_replace):
|
|
path = _save_credentials("http://c", "hid", "at", "rt")
|
|
self.assertEqual(len(tmp_perms_at_replace), 1)
|
|
self.assertEqual(oct(tmp_perms_at_replace[0]), oct(0o600))
|
|
self.assertEqual(oct(path.stat().st_mode & 0o777), oct(0o600))
|
|
|
|
def test_cleanup_on_write_failure(self) -> None:
|
|
"""Temp file is removed and no credentials remain if replace fails."""
|
|
from bot_bottle.cli.login import _save_credentials
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
with patch("os.replace", side_effect=OSError("disk full")):
|
|
with self.assertRaises(OSError):
|
|
_save_credentials("http://c", "hid", "at", "rt")
|
|
leftovers = [f for f in os.listdir(tmp) if f.startswith(".console-")]
|
|
self.assertEqual(leftovers, [])
|
|
|
|
|
|
class TestCmdLoginMissingUrl(unittest.TestCase):
|
|
def test_help_returns_0(self) -> None:
|
|
from bot_bottle.cli.login import cmd_login
|
|
|
|
self.assertEqual(cmd_login(["--help"]), 0)
|
|
|
|
def test_returns_1_without_url(self) -> None:
|
|
from bot_bottle.cli.login import cmd_login
|
|
with patch.dict(os.environ, {}, clear=True):
|
|
os.environ.pop("BB_CONSOLE_URL", None)
|
|
result = cmd_login([])
|
|
self.assertEqual(result, 1)
|
|
|
|
def test_reads_env_var(self) -> None:
|
|
"""Exits 1 (network error) not because of missing URL when env var is set."""
|
|
from bot_bottle.cli.login import cmd_login
|
|
|
|
def _fail_post(_url: str, _payload: dict[str, Any]) -> dict[str, Any]:
|
|
raise OSError("connection refused")
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(
|
|
os.environ,
|
|
{
|
|
"BB_CONSOLE_URL": "http://localhost:9999",
|
|
"BOT_BOTTLE_ROOT": tmp,
|
|
},
|
|
):
|
|
with patch("bot_bottle.cli.login._post", side_effect=_fail_post):
|
|
result = cmd_login([])
|
|
self.assertEqual(result, 1)
|
|
|
|
|
|
class TestCmdLoginFlow(unittest.TestCase):
|
|
def _run_with_mocks(
|
|
self, poll_responses: list[dict[str, Any]], tmp: str
|
|
) -> int:
|
|
from bot_bottle.cli.login import cmd_login
|
|
|
|
start_resp = {
|
|
"device_code": "dc123",
|
|
"user_code": "ABC-DEF",
|
|
"expires_in": 300,
|
|
"poll_interval": 0,
|
|
}
|
|
|
|
poll_iter = iter(poll_responses)
|
|
|
|
def _fake_post(
|
|
_url: str, _payload: dict[str, Any]
|
|
) -> dict[str, Any]:
|
|
return start_resp
|
|
|
|
def _fake_get(_url: str) -> tuple[int, dict[str, Any]]:
|
|
return 200, next(poll_iter, {"status": "pending"})
|
|
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
with patch("bot_bottle.cli.login._post", side_effect=_fake_post):
|
|
with patch("bot_bottle.cli.login._get", side_effect=_fake_get):
|
|
with patch("time.sleep"):
|
|
return cmd_login(["--console-url", "http://console"])
|
|
|
|
def test_approved_flow_returns_0(self) -> None:
|
|
approved = {
|
|
"status": "approved",
|
|
"host_id": "hid",
|
|
"access_token": "at",
|
|
"refresh_token": "rt",
|
|
}
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
result = self._run_with_mocks(
|
|
[{"status": "pending"}, approved], tmp
|
|
)
|
|
self.assertEqual(result, 0)
|
|
with open(os.path.join(tmp, "console.json"), encoding="utf-8") as f:
|
|
creds = json.loads(f.read())
|
|
self.assertEqual(creds["host_id"], "hid")
|
|
|
|
def test_denied_flow_returns_1(self) -> None:
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
result = self._run_with_mocks([{"status": "denied"}], tmp)
|
|
self.assertEqual(result, 1)
|
|
|
|
def test_timeout_returns_1(self) -> None:
|
|
from bot_bottle.cli.login import cmd_login
|
|
|
|
start_resp = {
|
|
"device_code": "dc",
|
|
"user_code": "ZZZ-ZZZ",
|
|
"expires_in": 0, # already expired; loop never runs
|
|
"poll_interval": 2,
|
|
}
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
with patch("bot_bottle.cli.login._post", return_value=start_resp):
|
|
result = cmd_login(["--console-url", "http://console"])
|
|
self.assertEqual(result, 1)
|
|
|
|
def test_poll_interval_from_server_is_used(self) -> None:
|
|
"""time.sleep must be called with the server-provided poll_interval."""
|
|
from bot_bottle.cli.login import cmd_login
|
|
|
|
server_interval = 7
|
|
start_resp = {
|
|
"device_code": "dc",
|
|
"user_code": "ABC-DEF",
|
|
"expires_in": 300,
|
|
"poll_interval": server_interval,
|
|
}
|
|
approved = {
|
|
"status": "approved",
|
|
"host_id": "hid",
|
|
"access_token": "at",
|
|
"refresh_token": "rt",
|
|
}
|
|
poll_iter = iter([{"status": "pending"}, approved])
|
|
|
|
def _fake_get(_url: str) -> tuple[int, dict[str, str]]:
|
|
return 200, next(poll_iter)
|
|
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
with patch.dict(os.environ, {"BOT_BOTTLE_ROOT": tmp}):
|
|
with patch("bot_bottle.cli.login._post", return_value=start_resp):
|
|
with patch(
|
|
"bot_bottle.cli.login._get", side_effect=_fake_get
|
|
):
|
|
with patch("time.sleep") as mock_sleep:
|
|
result = cmd_login(["--console-url", "http://console"])
|
|
|
|
self.assertEqual(result, 0)
|
|
self.assertTrue(mock_sleep.called)
|
|
for call in mock_sleep.call_args_list:
|
|
self.assertEqual(call.args[0], server_interval)
|
|
|
|
|
|
class TestDispatcherRegistration(unittest.TestCase):
|
|
def test_login_in_commands(self) -> None:
|
|
from bot_bottle.cli import COMMANDS
|
|
self.assertIn("login", COMMANDS)
|
|
|
|
def test_login_in_no_migration(self) -> None:
|
|
from bot_bottle.cli import NO_MIGRATION_COMMANDS
|
|
self.assertIn("login", NO_MIGRATION_COMMANDS)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|