Runs live, versioned Python application objects on one VM, with a suite of apps: projects, notes, tasks, files and more.

0 downloads

dbbasic-object-server/tests/test_deployment_checks.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-object-server.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-object-server.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-object-server.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 signup: the person chooses the password and name on the confirm page 83c7aa6 2 weeks, 5 days ago History
test_deployment_checks.py · 13.1 KB · 410 lines
1import json
2import stat
3from datetime import datetime, timedelta, timezone
4from pathlib import Path
5
6import deployment_checks
7import object_record_changes
8
9
10def chmod(path: Path, mode: int):
11 path.chmod(mode)
12 return path
13
14
15def current_owner_group(path: Path) -> tuple[str, str]:
16 owner, group = deployment_checks._owner_group(path)
17 return owner, group
18
19
20def make_layout(tmp_path):
21 code_dir = tmp_path / "opt" / "dbbasic-object-server"
22 objects_dir = tmp_path / "var" / "lib" / "dbbasic-object-server" / "objects"
23 data_dir = tmp_path / "var" / "lib" / "dbbasic-object-server" / "data"
24 env_file = tmp_path / "etc" / "dbbasic-object-server.env"
25 service_file = tmp_path / "etc" / "systemd" / "system" / "dbbasic-object-server.service"
26 journald_dropin = tmp_path / "etc" / "systemd" / "journald.conf.d" / "99-dbbasic.conf"
27
28 for directory in [code_dir, objects_dir, data_dir, env_file.parent, service_file.parent, journald_dropin.parent]:
29 directory.mkdir(parents=True, exist_ok=True)
30 env_file.write_text("DBBASIC_ENABLE_SOURCE_WRITES=false\n")
31 service_file.write_text(
32 "[Service]\n"
33 "User=dbbasic\n"
34 "ExecStart=/opt/dbbasic-object-server/.venv/bin/uvicorn object_server:app "
35 "--host 127.0.0.1 --port 8001 --no-access-log\n"
36 )
37 journald_dropin.write_text("[Journal]\nSystemMaxUse=128M\nMaxRetentionSec=7day\n")
38 chmod(code_dir, 0o755)
39 chmod(objects_dir, 0o750)
40 chmod(data_dir, 0o750)
41 chmod(env_file, 0o640)
42 chmod(service_file, 0o644)
43 chmod(journald_dropin, 0o644)
44
45 return code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin
46
47
48def check_layout(tmp_path, **overrides):
49 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
50 owner, group = current_owner_group(code_dir)
51 defaults = {
52 "code_dir": code_dir,
53 "objects_dir": objects_dir,
54 "data_dir": data_dir,
55 "env_file": env_file,
56 "service_file": service_file,
57 "journald_dropin": journald_dropin,
58 "service_user": owner,
59 "service_group": group,
60 "env_owner": owner,
61 "system_owner": owner,
62 "system_group": group,
63 }
64 defaults.update(overrides)
65 return deployment_checks.check_single_vm_layout(**defaults)
66
67
68def test_single_vm_layout_passes_for_expected_paths(tmp_path):
69 results = check_layout(tmp_path)
70
71 assert [result.status for result in results] == ["ok", "ok", "ok", "ok", "ok", "ok"]
72 assert not deployment_checks.has_errors(results)
73
74
75def test_runtime_directories_warn_when_visible_to_other_users(tmp_path):
76 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
77 objects_dir.chmod(0o755)
78 data_dir.chmod(0o755)
79 owner, group = current_owner_group(code_dir)
80
81 results = deployment_checks.check_single_vm_layout(
82 code_dir=code_dir,
83 objects_dir=objects_dir,
84 data_dir=data_dir,
85 env_file=env_file,
86 service_file=service_file,
87 journald_dropin=journald_dropin,
88 service_user=owner,
89 service_group=group,
90 env_owner=owner,
91 system_owner=owner,
92 system_group=group,
93 )
94
95 warnings = [result for result in results if result.status == "warning"]
96 assert [warning.name for warning in warnings] == [
97 "object source directory",
98 "data directory",
99 ]
100 assert not deployment_checks.has_errors(results)
101
102
103def test_group_writable_runtime_directory_is_an_error(tmp_path):
104 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
105 data_dir.chmod(0o770)
106 owner, group = current_owner_group(code_dir)
107
108 results = deployment_checks.check_single_vm_layout(
109 code_dir=code_dir,
110 objects_dir=objects_dir,
111 data_dir=data_dir,
112 env_file=env_file,
113 service_file=service_file,
114 journald_dropin=journald_dropin,
115 service_user=owner,
116 service_group=group,
117 env_owner=owner,
118 system_owner=owner,
119 system_group=group,
120 )
121
122 assert any(result.status == "error" and result.name == "data directory" for result in results)
123 assert deployment_checks.has_errors(results)
124
125
126def test_environment_file_rejects_world_readable_secrets(tmp_path):
127 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
128 env_file.chmod(0o644)
129 owner, group = current_owner_group(code_dir)
130
131 results = deployment_checks.check_single_vm_layout(
132 code_dir=code_dir,
133 objects_dir=objects_dir,
134 data_dir=data_dir,
135 env_file=env_file,
136 service_file=service_file,
137 journald_dropin=journald_dropin,
138 service_user=owner,
139 service_group=group,
140 env_owner=owner,
141 system_owner=owner,
142 system_group=group,
143 )
144
145 assert any(result.status == "error" and result.name == "environment file" for result in results)
146 assert deployment_checks.has_errors(results)
147
148
149def test_missing_service_file_is_an_error(tmp_path):
150 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
151 service_file.unlink()
152 owner, group = current_owner_group(code_dir)
153
154 results = deployment_checks.check_single_vm_layout(
155 code_dir=code_dir,
156 objects_dir=objects_dir,
157 data_dir=data_dir,
158 env_file=env_file,
159 service_file=service_file,
160 journald_dropin=journald_dropin,
161 service_user=owner,
162 service_group=group,
163 env_owner=owner,
164 system_owner=owner,
165 system_group=group,
166 )
167
168 assert any(result.status == "error" and result.name == "systemd service file" for result in results)
169 assert deployment_checks.has_errors(results)
170
171
172def test_service_file_warns_when_uvicorn_access_logs_are_enabled(tmp_path):
173 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
174 service_file.write_text(
175 "[Service]\n"
176 "ExecStart=/opt/dbbasic-object-server/.venv/bin/uvicorn "
177 "object_server:app --host 127.0.0.1 --port 8001\n"
178 )
179 owner, group = current_owner_group(code_dir)
180
181 results = deployment_checks.check_single_vm_layout(
182 code_dir=code_dir,
183 objects_dir=objects_dir,
184 data_dir=data_dir,
185 env_file=env_file,
186 service_file=service_file,
187 journald_dropin=journald_dropin,
188 service_user=owner,
189 service_group=group,
190 env_owner=owner,
191 system_owner=owner,
192 system_group=group,
193 )
194
195 assert any(
196 result.status == "warning"
197 and result.name == "systemd service file"
198 and "access logs are enabled" in result.message
199 for result in results
200 )
201 assert not deployment_checks.has_errors(results)
202
203
204def test_missing_journald_dropin_warns_without_failing(tmp_path):
205 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
206 journald_dropin.unlink()
207 owner, group = current_owner_group(code_dir)
208
209 results = deployment_checks.check_single_vm_layout(
210 code_dir=code_dir,
211 objects_dir=objects_dir,
212 data_dir=data_dir,
213 env_file=env_file,
214 service_file=service_file,
215 journald_dropin=journald_dropin,
216 service_user=owner,
217 service_group=group,
218 env_owner=owner,
219 system_owner=owner,
220 system_group=group,
221 )
222
223 assert any(
224 result.status == "warning"
225 and result.name == "journald retention drop-in"
226 and "missing" in result.message
227 for result in results
228 )
229 assert not deployment_checks.has_errors(results)
230
231
232def test_journald_dropin_warns_when_missing_size_cap(tmp_path):
233 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
234 journald_dropin.write_text("[Journal]\nMaxRetentionSec=7day\n")
235 owner, group = current_owner_group(code_dir)
236
237 results = deployment_checks.check_single_vm_layout(
238 code_dir=code_dir,
239 objects_dir=objects_dir,
240 data_dir=data_dir,
241 env_file=env_file,
242 service_file=service_file,
243 journald_dropin=journald_dropin,
244 service_user=owner,
245 service_group=group,
246 env_owner=owner,
247 system_owner=owner,
248 system_group=group,
249 )
250
251 assert any(
252 result.status == "warning"
253 and result.name == "journald retention drop-in"
254 and "missing journal size cap" in result.message
255 for result in results
256 )
257 assert not deployment_checks.has_errors(results)
258
259
260def test_cli_returns_json_and_success_for_warnings(tmp_path, capsys):
261 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
262 objects_dir.chmod(0o755)
263 owner, group = current_owner_group(code_dir)
264
265 exit_code = deployment_checks.main(
266 [
267 "--code-dir",
268 str(code_dir),
269 "--objects-dir",
270 str(objects_dir),
271 "--data-dir",
272 str(data_dir),
273 "--env-file",
274 str(env_file),
275 "--service-file",
276 str(service_file),
277 "--journald-dropin",
278 str(journald_dropin),
279 "--service-user",
280 owner,
281 "--service-group",
282 group,
283 "--env-owner",
284 owner,
285 "--system-owner",
286 owner,
287 "--system-group",
288 group,
289 "--json",
290 ]
291 )
292
293 payload = json.loads(capsys.readouterr().out)
294 assert exit_code == 0
295 assert any(result["status"] == "warning" for result in payload)
296
297
298def test_cli_uses_environment_paths(tmp_path, monkeypatch):
299 code_dir, objects_dir, data_dir, env_file, service_file, journald_dropin = make_layout(tmp_path)
300 owner, group = current_owner_group(code_dir)
301 monkeypatch.setenv("DBBASIC_OBJECTS_DIR", str(objects_dir))
302 monkeypatch.setenv("DBBASIC_DATA_DIR", str(data_dir))
303
304 exit_code = deployment_checks.main(
305 [
306 "--code-dir",
307 str(code_dir),
308 "--env-file",
309 str(env_file),
310 "--service-file",
311 str(service_file),
312 "--journald-dropin",
313 str(journald_dropin),
314 "--service-user",
315 owner,
316 "--service-group",
317 group,
318 "--env-owner",
319 owner,
320 "--system-owner",
321 owner,
322 "--system-group",
323 group,
324 ]
325 )
326
327 assert exit_code == 0
328
329
330def test_mode_format_includes_leading_zero():
331 assert deployment_checks._mode(stat.S_IMODE(0o750)) == "0750"
332
333
334def test_unattributed_record_changes_ok_when_no_log(tmp_path):
335 results = deployment_checks.check_unattributed_record_changes(data_dir=tmp_path / "data")
336
337 assert [result.status for result in results] == ["ok"]
338
339
340def test_unattributed_record_changes_ok_when_all_attributed(tmp_path):
341 data_dir = tmp_path / "data"
342 object_record_changes.append_record_change(
343 collection="contacts",
344 record_id="c1",
345 action="create",
346 before=None,
347 after={"id": "c1"},
348 actor="admin",
349 base_dir=data_dir,
350 )
351
352 results = deployment_checks.check_unattributed_record_changes(data_dir=data_dir)
353
354 assert [result.status for result in results] == ["ok"]
355
356
357def test_unattributed_record_changes_warns_and_counts(tmp_path):
358 data_dir = tmp_path / "data"
359 object_record_changes.append_record_change(
360 collection="contacts",
361 record_id="c1",
362 action="create",
363 before=None,
364 after={"id": "c1"},
365 actor="unattributed",
366 base_dir=data_dir,
367 )
368 object_record_changes.append_record_change(
369 collection="contacts",
370 record_id="c2",
371 action="create",
372 before=None,
373 after={"id": "c2"},
374 actor="admin",
375 base_dir=data_dir,
376 )
377
378 results = deployment_checks.check_unattributed_record_changes(data_dir=data_dir)
379
380 assert len(results) == 1
381 assert results[0].status == "warning"
382 assert "1 unattributed" in results[0].message
383 assert "contacts=1" in results[0].message
384 # Never a hard failure -- visibility only, per the deployment check contract.
385 assert not deployment_checks.has_errors(results)
386
387
388def test_unattributed_record_changes_ignores_entries_outside_window(tmp_path):
389 data_dir = tmp_path / "data"
390 path = object_record_changes.record_changes_file("contacts", base_dir=data_dir)
391 path.parent.mkdir(parents=True, exist_ok=True)
392 stale_timestamp = (datetime.now(timezone.utc) - timedelta(hours=48)).isoformat()
393 entry = {
394 "change_id": "11111111-1111-4111-8111-111111111111",
395 "timestamp": stale_timestamp,
396 "collection": "contacts",
397 "record_id": "c1",
398 "action": "create",
399 "actor": "unattributed",
400 "message": "Created record",
401 "correlation_id": None,
402 "changed_fields": ["id"],
403 "before": None,
404 "after": {"id": "c1"},
405 }
406 path.write_text(json.dumps(entry) + "\n")
407
408 results = deployment_checks.check_unattributed_record_changes(data_dir=data_dir, window_hours=24)
409
410 assert [result.status for result in results] == ["ok"]