285 lines
13 KiB
Python
285 lines
13 KiB
Python
import hashlib
|
||
import json
|
||
import os
|
||
import tempfile
|
||
import unittest
|
||
|
||
from _common import SETTINGS, agent
|
||
from fake_hub import FakeHub
|
||
|
||
CUR = agent.AGENT_VERSION
|
||
NEXT = CUR + 1
|
||
|
||
|
||
class UpdateStateTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.dir = tempfile.TemporaryDirectory()
|
||
self.path = os.path.join(self.dir.name, "update.json")
|
||
|
||
def tearDown(self):
|
||
self.dir.cleanup()
|
||
|
||
def test_write_and_read(self):
|
||
d = agent.write_update_state(self.path, "staged", 5, 6, "abc")
|
||
self.assertEqual(agent.read_update_state(self.path), d)
|
||
self.assertEqual((d["state"], d["from_version"], d["to_version"], d["sha256"], d["error"]), ("staged", 5, 6, "abc", None))
|
||
self.assertTrue(d["at"])
|
||
self.assertEqual(os.listdir(self.dir.name), ["update.json"]) # временный файл не остался
|
||
|
||
def test_read_missing(self):
|
||
self.assertIsNone(agent.read_update_state(self.path))
|
||
|
||
def test_read_update_state_garbage(self):
|
||
for text in ('{"state": "tri', "[1, 2]", ""):
|
||
with open(self.path, "w", encoding="utf-8") as f:
|
||
f.write(text)
|
||
self.assertIsNone(agent.read_update_state(self.path))
|
||
|
||
def test_confirm_trial_of_this_version(self):
|
||
u = agent.Updater(None, self.dir.name, 1)
|
||
agent.write_update_state(u.state_path, "trial", 4, agent.AGENT_VERSION, "s")
|
||
u.confirm()
|
||
st = agent.read_update_state(u.state_path)
|
||
self.assertEqual((st["state"], st["from_version"], st["to_version"], st["sha256"]), ("ok", 4, agent.AGENT_VERSION, "s"))
|
||
|
||
def test_confirm_ignores_other_states(self):
|
||
u = agent.Updater(None, self.dir.name, 1)
|
||
u.confirm()
|
||
self.assertIsNone(u.state()) # нет файла — не создаётся
|
||
agent.write_update_state(u.state_path, "trial", 4, agent.AGENT_VERSION + 1, "s")
|
||
u.confirm()
|
||
self.assertEqual(u.state()["state"], "trial") # пробная другая версия — не наша
|
||
agent.write_update_state(u.state_path, "rolled_back", 5, 6, "s", "код 1 через 3 с")
|
||
u.confirm()
|
||
self.assertEqual(u.state()["state"], "rolled_back")
|
||
|
||
|
||
def make_release(version, body="print('ok')\n"):
|
||
content = "AGENT_VERSION = %d\n%s" % (version, body)
|
||
return {"version": version, "sha256": hashlib.sha256(content.encode("utf-8")).hexdigest(), "content": content}
|
||
|
||
|
||
class UpdaterCheckTest(unittest.TestCase):
|
||
def setUp(self):
|
||
self.dir = tempfile.TemporaryDirectory()
|
||
self.hub = FakeHub(SETTINGS)
|
||
cfg = {"hub_url": self.hub.base_url, "hub_token": self.hub.token, "timeout": 5}
|
||
self.u = agent.Updater(agent.HubClient(cfg), self.dir.name, 1)
|
||
self.selftests = []
|
||
self.code = 0
|
||
self.u.run_selftest = lambda path: (self.selftests.append(path), (self.code, "вывод selftest"))[1]
|
||
self.now = [1000.0]
|
||
self.u.clock = lambda: self.now[0]
|
||
|
||
def tearDown(self):
|
||
self.hub.stop()
|
||
self.dir.cleanup()
|
||
|
||
def ref(self, rel):
|
||
return {"version": rel["version"], "sha256": rel["sha256"]}
|
||
|
||
def capture_logs(self):
|
||
logs = []
|
||
orig = agent.log
|
||
agent.log = logs.append
|
||
self.addCleanup(setattr, agent, "log", orig)
|
||
return logs
|
||
|
||
def test_incomplete_release_ignored_with_hourly_hint(self):
|
||
logs = self.capture_logs()
|
||
for ref in ({"version": NEXT, "sha256": None}, {"version": str(NEXT), "sha256": "a" * 64},
|
||
{"version": True, "sha256": "a" * 64}, {"version": NEXT, "sha256": "A" * 64},
|
||
{"version": NEXT, "sha256": "a" * 63}, {"version": NEXT, "sha256": "a" * 64 + "\n"}):
|
||
self.assertFalse(self.u.check(ref))
|
||
self.now[0] += 3600
|
||
self.assertFalse(self.u.check({"version": NEXT, "sha256": None}))
|
||
self.assertEqual(sum(1 for l in logs if l.startswith("хаб прислал неполную публикацию")), 2)
|
||
self.assertEqual(self.hub.release_requests, 0)
|
||
self.assertIsNone(self.u.state())
|
||
|
||
def test_incomplete_release_hint_is_bounded(self):
|
||
"""M-4: подсказка не печатает произвольно длинный мусор от хаба целиком."""
|
||
logs = self.capture_logs()
|
||
self.assertFalse(self.u.check({"version": NEXT, "sha256": "x" * 10000}))
|
||
hints = [l for l in logs if l.startswith("хаб прислал неполную публикацию")]
|
||
self.assertEqual(len(hints), 1)
|
||
self.assertLess(len(hints[0]), 300)
|
||
|
||
def test_hints_have_separate_timers(self):
|
||
logs = self.capture_logs()
|
||
self.u.launcher_version = None
|
||
self.hub.release = make_release(NEXT)
|
||
self.assertFalse(self.u.check({"version": NEXT, "sha256": None}))
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertEqual(sum(1 for l in logs if l.startswith("хаб прислал неполную публикацию")), 1)
|
||
self.assertEqual(logs.count("доступна v%d; для самообновления запускайте через run.py" % NEXT), 1)
|
||
|
||
def test_write_error_is_transient(self):
|
||
self.hub.release = make_release(NEXT)
|
||
ref = self.ref(self.hub.release)
|
||
self.u.new_path = os.path.join(self.dir.name, "нет-каталога", "agent.py.new") # open() → FileNotFoundError
|
||
self.assertFalse(self.u.check(ref))
|
||
self.assertIsNone(self.u.state())
|
||
self.assertEqual(self.selftests, [])
|
||
self.now[0] += 299
|
||
self.assertFalse(self.u.check(ref))
|
||
self.assertEqual(self.hub.release_requests, 1) # раньше 5 минут не повторяет
|
||
|
||
def test_selftest_os_error_is_transient(self):
|
||
self.hub.release = make_release(NEXT)
|
||
def boom(path):
|
||
raise OSError(28, "No space left on device")
|
||
self.u.run_selftest = boom
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertIsNone(self.u.state())
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
|
||
def test_staged_write_error_is_transient(self):
|
||
self.hub.release = make_release(NEXT)
|
||
self.u.state_path = os.path.join(self.dir.name, "нет-каталога", "update.json")
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release))) # без staged выходить с 75 нельзя
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
|
||
def test_reject_write_error_only_logged(self):
|
||
rel = make_release(NEXT)
|
||
self.hub.release = dict(rel, content=rel["content"] + "# подмена\n")
|
||
self.u.state_path = os.path.join(self.dir.name, "нет-каталога", "update.json")
|
||
logs = self.capture_logs()
|
||
self.assertFalse(self.u.check(self.ref(rel))) # не бросает
|
||
self.assertTrue(any(l.startswith("не удалось записать update.json") for l in logs), logs)
|
||
|
||
def test_good_version_is_staged(self):
|
||
rel = make_release(NEXT)
|
||
self.hub.release = rel
|
||
self.assertTrue(self.u.check(self.ref(rel)))
|
||
with open(self.u.new_path, encoding="utf-8") as f:
|
||
self.assertEqual(f.read(), rel["content"])
|
||
st = self.u.state()
|
||
self.assertEqual((st["state"], st["from_version"], st["to_version"], st["sha256"]), ("staged", CUR, NEXT, rel["sha256"]))
|
||
self.assertEqual(self.selftests, [self.u.new_path])
|
||
|
||
def test_not_newer_or_disabled_or_no_release(self):
|
||
self.hub.release = make_release(CUR)
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertFalse(self.u.check(None))
|
||
self.hub.release = make_release(NEXT)
|
||
self.u.enabled = False
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertEqual(self.hub.release_requests, 0)
|
||
|
||
def test_sha_mismatch_rejected_once(self):
|
||
rel = make_release(NEXT)
|
||
self.hub.release = dict(rel, content=rel["content"] + "# подмена\n")
|
||
ref = self.ref(rel)
|
||
self.hub.release["sha256"] = rel["sha256"]
|
||
self.assertFalse(self.u.check(ref))
|
||
st = self.u.state()
|
||
self.assertEqual((st["state"], st["to_version"], st["error"]), ("rejected", NEXT, "sha256 не сходится"))
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
self.assertFalse(self.u.check(ref))
|
||
self.assertEqual(self.hub.release_requests, 1) # отвергнутую версию больше не качает
|
||
|
||
def test_syntax_error_and_wrong_version_rejected(self):
|
||
bad = make_release(NEXT, body="def (:\n")
|
||
self.hub.release = bad
|
||
self.assertFalse(self.u.check(self.ref(bad)))
|
||
self.assertIn("не компилируется", self.u.state()["error"])
|
||
wrong = make_release(NEXT + 1)
|
||
wrong = dict(wrong, version=NEXT + 2)
|
||
self.hub.release = wrong
|
||
self.assertFalse(self.u.check(self.ref(wrong)))
|
||
self.assertIn("AGENT_VERSION", self.u.state()["error"])
|
||
self.assertEqual(self.selftests, [])
|
||
|
||
def test_selftest_bad_code_rejected(self):
|
||
self.hub.release = make_release(NEXT)
|
||
self.code = 1
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
st = self.u.state()
|
||
self.assertEqual(st["state"], "rejected")
|
||
self.assertTrue(st["error"].startswith("selftest: код 1"))
|
||
self.assertIn("вывод selftest", st["error"])
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
|
||
def test_selftest_unavailable_is_transient(self):
|
||
self.hub.release = make_release(NEXT)
|
||
self.code = 3
|
||
ref = self.ref(self.hub.release)
|
||
self.assertFalse(self.u.check(ref))
|
||
self.assertIsNone(self.u.state()) # update.json не тронут
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
self.now[0] += 299
|
||
self.assertFalse(self.u.check(ref))
|
||
self.assertEqual(len(self.selftests), 1) # раньше 5 минут не повторяет
|
||
self.now[0] += 2
|
||
self.code = 0
|
||
self.assertTrue(self.u.check(ref))
|
||
|
||
def test_selftest_timeout_is_transient(self):
|
||
self.hub.release = make_release(NEXT)
|
||
self.code = None
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertIsNone(self.u.state())
|
||
|
||
def test_download_failure_is_transient(self):
|
||
rel = make_release(NEXT) # в claim есть, а /agent/release — 404
|
||
self.assertFalse(self.u.check(self.ref(rel)))
|
||
self.assertIsNone(self.u.state())
|
||
|
||
def test_release_changed_between_requests_is_transient(self):
|
||
old, new = make_release(NEXT), make_release(NEXT + 1)
|
||
self.hub.release = new
|
||
self.assertFalse(self.u.check(self.ref(old)))
|
||
self.assertIsNone(self.u.state())
|
||
self.assertEqual(self.selftests, [])
|
||
|
||
def test_rolled_back_same_sha_not_retried(self):
|
||
rel = make_release(NEXT)
|
||
self.hub.release = rel
|
||
agent.write_update_state(self.u.state_path, "rolled_back", CUR, NEXT, rel["sha256"], "код 1 через 3 с")
|
||
self.assertFalse(self.u.check(self.ref(rel)))
|
||
fixed = make_release(NEXT, body="print('fixed')\n")
|
||
self.hub.release = fixed
|
||
self.assertTrue(self.u.check(self.ref(fixed))) # тот же номер, другой sha — пробуем
|
||
|
||
def test_without_launcher_only_hint(self):
|
||
self.u.launcher_version = None
|
||
self.hub.release = make_release(NEXT)
|
||
logs = []
|
||
orig = agent.log
|
||
agent.log = logs.append
|
||
try:
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.now[0] += 3600
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
finally:
|
||
agent.log = orig
|
||
self.assertEqual(logs.count("доступна v%d; для самообновления запускайте через run.py" % NEXT), 2)
|
||
self.assertEqual(self.hub.release_requests, 0)
|
||
|
||
def test_stop_during_selftest_is_not_reject(self):
|
||
self.hub.release = make_release(NEXT)
|
||
stop = [False]
|
||
self.u.should_stop = lambda: stop[0]
|
||
|
||
def selftest(path):
|
||
stop[0] = True # Ctrl-C пришёл и selftest упал с 1
|
||
return 1, "KeyboardInterrupt"
|
||
self.u.run_selftest = selftest
|
||
self.assertFalse(self.u.check(self.ref(self.hub.release)))
|
||
self.assertIsNone(self.u.state())
|
||
self.assertFalse(os.path.exists(self.u.new_path))
|
||
|
||
def test_real_selftest_runs_new_file(self):
|
||
u = agent.Updater(None, self.dir.name, 1, config_path=os.path.join(self.dir.name, "agent.json"))
|
||
path = os.path.join(self.dir.name, "agent.py.new")
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
f.write("import sys\nprint('args', sys.argv[1:])\nsys.exit(3)\n")
|
||
code, out = u._run_selftest(path)
|
||
self.assertEqual(code, 3)
|
||
self.assertIn("'--config', '%s', 'selftest'" % os.path.join(self.dir.name, "agent.json"), out)
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|