askrobots / dbbasic-object-server
Public
Runs live, versioned Python application objects on one VM, with a suite of apps: projects, notes, tasks, files and more.
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
| 1 | import json |
| 2 | import stat |
| 3 | from datetime import datetime, timedelta, timezone |
| 4 | from pathlib import Path |
| 5 | |
| 6 | import deployment_checks |
| 7 | import object_record_changes |
| 8 | |
| 9 | |
| 10 | def chmod(path: Path, mode: int): |
| 11 | path.chmod(mode) |
| 12 | return path |
| 13 | |
| 14 | |
| 15 | def current_owner_group(path: Path) -> tuple[str, str]: |
| 16 | owner, group = deployment_checks._owner_group(path) |
| 17 | return owner, group |
| 18 | |
| 19 | |
| 20 | def 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 | |
| 48 | def 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 | |
| 68 | def 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 | |
| 75 | def 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 | |
| 103 | def 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 | |
| 126 | def 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 | |
| 149 | def 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 | |
| 172 | def 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 | |
| 204 | def 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 | |
| 232 | def 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 | |
| 260 | def 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 | |
| 298 | def 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 | |
| 330 | def test_mode_format_includes_leading_zero(): |
| 331 | assert deployment_checks._mode(stat.S_IMODE(0o750)) == "0750" |
| 332 | |
| 333 | |
| 334 | def 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 | |
| 340 | def 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 | |
| 357 | def 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 | |
| 388 | def 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"] |