test_add_ita_query_account.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310
  1. import ast
  2. import io
  3. import json
  4. import subprocess
  5. import sys
  6. import tempfile
  7. import unittest
  8. from contextlib import redirect_stderr, redirect_stdout
  9. from pathlib import Path
  10. import requests
  11. from tools.add_ita_query_account import (
  12. ACCOUNT_POOL,
  13. ACCOUNT_UPLOAD_URL,
  14. SERVICE_ID,
  15. run_account_upload,
  16. )
  17. class FakeResponse:
  18. def __init__(self, *, status_code=200, body=None, json_error=None):
  19. self.status_code = status_code
  20. self.body = body if body is not None else {"code": 0, "data": {"id": 42}}
  21. self.json_error = json_error
  22. def json(self):
  23. if self.json_error is not None:
  24. raise self.json_error
  25. return self.body
  26. class FakeSession:
  27. def __init__(self, *, response=None, error=None):
  28. self.response = response or FakeResponse()
  29. self.error = error
  30. self.calls = []
  31. self.trust_env = True
  32. def post(self, url, **kwargs):
  33. self.calls.append((url, kwargs))
  34. if self.error is not None:
  35. raise self.error
  36. return self.response
  37. class AddItaQueryAccountTests(unittest.TestCase):
  38. ENV = {
  39. "ITA_QUERY_USERNAME": "authorized-query@example.test",
  40. "ITA_QUERY_PASSWORD": "offline-password",
  41. "VS_ACCOUNT_UPLOAD_TOKEN": "offline-api-token",
  42. }
  43. @staticmethod
  44. def _run(*, env=None, apply=False, config_path=None, session=None):
  45. stdout = io.StringIO()
  46. stderr = io.StringIO()
  47. with redirect_stdout(stdout), redirect_stderr(stderr):
  48. exit_code = run_account_upload(
  49. env or {},
  50. apply=apply,
  51. non_interactive=True,
  52. config_path=config_path,
  53. session=session,
  54. )
  55. return exit_code, stdout.getvalue(), stderr.getvalue()
  56. def test_default_preflight_sends_no_request_and_needs_no_credentials(self):
  57. session = FakeSession(error=AssertionError("post must not be called"))
  58. exit_code, stdout, stderr = self._run(session=session)
  59. self.assertEqual(exit_code, 0)
  60. self.assertEqual(session.calls, [])
  61. self.assertIn(
  62. "ITA_ACCOUNT_UPLOAD_PREFLIGHT_OK "
  63. f"pool={ACCOUNT_POOL} service_id={SERVICE_ID} request_sent=false",
  64. stdout,
  65. )
  66. self.assertEqual(stderr, "")
  67. def test_cli_default_dry_run_starts_from_the_repository_root(self):
  68. repo_root = Path(__file__).resolve().parents[2]
  69. completed = subprocess.run(
  70. [sys.executable, str(repo_root / "tools" / "add_ita_query_account.py")],
  71. cwd=repo_root,
  72. check=False,
  73. capture_output=True,
  74. text=True,
  75. )
  76. self.assertEqual(completed.returncode, 0)
  77. self.assertIn("request_sent=false", completed.stdout)
  78. self.assertEqual(completed.stderr, "")
  79. def test_apply_sends_exactly_one_locked_pool_request_without_logging_secrets(self):
  80. session = FakeSession()
  81. exit_code, stdout, stderr = self._run(
  82. env=self.ENV,
  83. apply=True,
  84. session=session,
  85. )
  86. self.assertEqual(exit_code, 0)
  87. self.assertEqual(len(session.calls), 1)
  88. url, kwargs = session.calls[0]
  89. self.assertEqual(url, ACCOUNT_UPLOAD_URL)
  90. self.assertEqual(kwargs["json"]["pool_name"], ACCOUNT_POOL)
  91. self.assertEqual(kwargs["json"]["username"], self.ENV["ITA_QUERY_USERNAME"])
  92. self.assertEqual(kwargs["json"]["password"], self.ENV["ITA_QUERY_PASSWORD"])
  93. self.assertEqual(kwargs["json"]["extra_data"]["service_id"], SERVICE_ID)
  94. self.assertEqual(kwargs["timeout"], 10)
  95. self.assertFalse(session.trust_env)
  96. self.assertIn("account_id=42 request_count=1", stdout)
  97. combined_output = stdout + stderr
  98. for secret in self.ENV.values():
  99. self.assertNotIn(secret, combined_output)
  100. def test_apply_reads_ignored_local_config_and_logs_no_secret(self):
  101. local_values = {
  102. "username": "local-authorized@example.test",
  103. "password": "local-password",
  104. "account_upload_token": "local-api-token",
  105. }
  106. session = FakeSession()
  107. with tempfile.TemporaryDirectory() as temp_dir:
  108. config_path = Path(temp_dir) / "ita_query_account.local.json"
  109. config_path.write_text(json.dumps(local_values), encoding="utf-8")
  110. config_path.chmod(0o600)
  111. exit_code, stdout, stderr = self._run(
  112. apply=True,
  113. config_path=config_path,
  114. session=session,
  115. )
  116. self.assertEqual(exit_code, 0)
  117. self.assertEqual(len(session.calls), 1)
  118. _, kwargs = session.calls[0]
  119. self.assertEqual(kwargs["json"]["username"], local_values["username"])
  120. self.assertEqual(kwargs["json"]["password"], local_values["password"])
  121. combined_output = stdout + stderr
  122. for secret in local_values.values():
  123. self.assertNotIn(secret, combined_output)
  124. def test_invalid_local_config_fails_before_request_without_content_leak(self):
  125. session = FakeSession(error=AssertionError("post must not be called"))
  126. with tempfile.TemporaryDirectory() as temp_dir:
  127. config_path = Path(temp_dir) / "ita_query_account.local.json"
  128. config_path.write_text('{"password": "private-value",', encoding="utf-8")
  129. config_path.chmod(0o600)
  130. exit_code, stdout, stderr = self._run(
  131. apply=True,
  132. config_path=config_path,
  133. session=session,
  134. )
  135. self.assertEqual(exit_code, 2)
  136. self.assertEqual(session.calls, [])
  137. self.assertEqual(stdout, "")
  138. self.assertIn("local config is invalid JSON", stderr)
  139. self.assertNotIn("private-value", stderr)
  140. def test_environment_values_override_local_config(self):
  141. local_values = {
  142. "username": "stale@example.test",
  143. "password": "stale-password",
  144. "account_upload_token": "stale-token",
  145. }
  146. session = FakeSession()
  147. with tempfile.TemporaryDirectory() as temp_dir:
  148. config_path = Path(temp_dir) / "ita_query_account.local.json"
  149. config_path.write_text(json.dumps(local_values), encoding="utf-8")
  150. config_path.chmod(0o600)
  151. exit_code, _, _ = self._run(
  152. env=self.ENV,
  153. apply=True,
  154. config_path=config_path,
  155. session=session,
  156. )
  157. self.assertEqual(exit_code, 0)
  158. _, kwargs = session.calls[0]
  159. self.assertEqual(kwargs["json"]["username"], self.ENV["ITA_QUERY_USERNAME"])
  160. self.assertEqual(kwargs["json"]["password"], self.ENV["ITA_QUERY_PASSWORD"])
  161. def test_missing_non_interactive_credentials_fails_before_request(self):
  162. session = FakeSession(error=AssertionError("post must not be called"))
  163. exit_code, stdout, stderr = self._run(
  164. apply=True,
  165. session=session,
  166. )
  167. self.assertEqual(exit_code, 2)
  168. self.assertEqual(session.calls, [])
  169. self.assertEqual(stdout, "")
  170. self.assertIn("ITA_ACCOUNT_UPLOAD_CONFIG_ERROR", stderr)
  171. def test_http_rejection_does_not_print_response_body_or_retry(self):
  172. response = FakeResponse(
  173. status_code=409,
  174. body={"message": "authorized-query@example.test already exists"},
  175. )
  176. session = FakeSession(response=response)
  177. exit_code, stdout, stderr = self._run(
  178. env=self.ENV,
  179. apply=True,
  180. session=session,
  181. )
  182. self.assertEqual(exit_code, 4)
  183. self.assertEqual(len(session.calls), 1)
  184. self.assertEqual(stdout, "")
  185. self.assertIn("status=409 request_count=1", stderr)
  186. self.assertNotIn("already exists", stderr)
  187. self.assertNotIn(self.ENV["ITA_QUERY_USERNAME"], stderr)
  188. def test_transport_error_is_uncertain_and_explicitly_forbids_blind_retry(self):
  189. session = FakeSession(error=requests.Timeout("sensitive request details"))
  190. exit_code, stdout, stderr = self._run(
  191. env=self.ENV,
  192. apply=True,
  193. session=session,
  194. )
  195. self.assertEqual(exit_code, 5)
  196. self.assertEqual(len(session.calls), 1)
  197. self.assertEqual(stdout, "")
  198. self.assertIn("ITA_ACCOUNT_UPLOAD_UNCERTAIN", stderr)
  199. self.assertIn("action=verify-admin-before-retry", stderr)
  200. self.assertNotIn("sensitive request details", stderr)
  201. def test_invalid_success_json_is_uncertain_not_success(self):
  202. session = FakeSession(
  203. response=FakeResponse(json_error=ValueError("secret response"))
  204. )
  205. exit_code, stdout, stderr = self._run(
  206. env=self.ENV,
  207. apply=True,
  208. session=session,
  209. )
  210. self.assertEqual(exit_code, 5)
  211. self.assertEqual(len(session.calls), 1)
  212. self.assertEqual(stdout, "")
  213. self.assertIn("type=InvalidJson", stderr)
  214. self.assertNotIn("secret response", stderr)
  215. def test_business_error_is_rejected_without_message_leak(self):
  216. session = FakeSession(
  217. response=FakeResponse(
  218. body={"code": 40001, "message": "private server detail"}
  219. )
  220. )
  221. exit_code, stdout, stderr = self._run(
  222. env=self.ENV,
  223. apply=True,
  224. session=session,
  225. )
  226. self.assertEqual(exit_code, 4)
  227. self.assertEqual(len(session.calls), 1)
  228. self.assertEqual(stdout, "")
  229. self.assertIn("status=business-error", stderr)
  230. self.assertNotIn("private server detail", stderr)
  231. def test_source_has_one_post_call_no_retry_loop_and_no_secret_cli_flags(self):
  232. source_path = (
  233. Path(__file__).resolve().parents[2]
  234. / "tools"
  235. / "add_ita_query_account.py"
  236. )
  237. source = source_path.read_text(encoding="utf-8")
  238. tree = ast.parse(source)
  239. upload_function = next(
  240. node
  241. for node in tree.body
  242. if isinstance(node, ast.FunctionDef)
  243. and node.name == "run_account_upload"
  244. )
  245. post_calls = [
  246. node
  247. for node in ast.walk(upload_function)
  248. if isinstance(node, ast.Call)
  249. and isinstance(node.func, ast.Attribute)
  250. and node.func.attr == "post"
  251. ]
  252. retry_loops = [
  253. node
  254. for node in ast.walk(upload_function)
  255. if isinstance(node, (ast.For, ast.While))
  256. ]
  257. self.assertEqual(len(post_calls), 1)
  258. self.assertEqual(retry_loops, [])
  259. self.assertNotIn("--username", source)
  260. self.assertNotIn("--password", source)
  261. self.assertNotIn("--token", source)
  262. if __name__ == "__main__":
  263. unittest.main()