askrobots / dbbasic-object-primitive
Public
Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.
test_self_logging.py · 13.0 KB · 391 lines
| 1 | """ |
| 2 | Unit tests for self-logging pattern |
| 3 | |
| 4 | Test-Driven Development: These tests are written FIRST, before implementation. |
| 5 | They define the expected behavior of self-logging. |
| 6 | |
| 7 | Self-Logging Pattern: |
| 8 | - Objects log to themselves (not to external log system) |
| 9 | - Logs stored in TSV files (human-readable, grep-able) |
| 10 | - Append-only (immutable history) |
| 11 | - Query logs (filter, time range, pagination) |
| 12 | - Each endpoint has its own log file |
| 13 | """ |
| 14 | |
| 15 | import pytest |
| 16 | import tempfile |
| 17 | import shutil |
| 18 | from pathlib import Path |
| 19 | from datetime import datetime, timedelta |
| 20 | |
| 21 | |
| 22 | class TestBasicLogging: |
| 23 | """Test basic self-logging functionality""" |
| 24 | |
| 25 | def setup_method(self): |
| 26 | """Create temporary directory for each test""" |
| 27 | self.temp_dir = Path(tempfile.mkdtemp()) |
| 28 | |
| 29 | def teardown_method(self): |
| 30 | """Clean up temporary directory""" |
| 31 | if self.temp_dir.exists(): |
| 32 | shutil.rmtree(self.temp_dir) |
| 33 | |
| 34 | def test_log_single_entry(self): |
| 35 | """Should log a single entry to TSV file""" |
| 36 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 37 | |
| 38 | logger = SelfLogger(object_id='test_endpoint', base_dir=self.temp_dir) |
| 39 | |
| 40 | logger.log( |
| 41 | level='INFO', |
| 42 | message='Test message', |
| 43 | method='GET', |
| 44 | ) |
| 45 | |
| 46 | # Check log file exists |
| 47 | log_file = self.temp_dir / 'logs' / 'test_endpoint' / 'log.tsv' |
| 48 | assert log_file.exists() |
| 49 | |
| 50 | # Check content |
| 51 | content = log_file.read_text() |
| 52 | lines = content.strip().split('\n') |
| 53 | |
| 54 | assert len(lines) == 2 # Header + 1 entry |
| 55 | assert 'timestamp' in lines[0] |
| 56 | assert 'Test message' in lines[1] |
| 57 | |
| 58 | def test_log_multiple_entries(self): |
| 59 | """Should log multiple entries in order""" |
| 60 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 61 | |
| 62 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 63 | |
| 64 | logger.log(level='INFO', message='First') |
| 65 | logger.log(level='INFO', message='Second') |
| 66 | logger.log(level='INFO', message='Third') |
| 67 | |
| 68 | log_file = self.temp_dir / 'logs' / 'test' / 'log.tsv' |
| 69 | content = log_file.read_text() |
| 70 | lines = content.strip().split('\n') |
| 71 | |
| 72 | assert len(lines) == 4 # Header + 3 entries |
| 73 | assert 'First' in lines[1] |
| 74 | assert 'Second' in lines[2] |
| 75 | assert 'Third' in lines[3] |
| 76 | |
| 77 | def test_log_with_metadata(self): |
| 78 | """Should include timestamp, level, and other metadata""" |
| 79 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 80 | |
| 81 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 82 | |
| 83 | before = datetime.now() |
| 84 | logger.log( |
| 85 | level='ERROR', |
| 86 | message='Something failed', |
| 87 | method='POST', |
| 88 | user_id='user-123', |
| 89 | request_id='req-456', |
| 90 | ) |
| 91 | after = datetime.now() |
| 92 | |
| 93 | # Read the entry |
| 94 | entries = logger.get_logs() |
| 95 | assert len(entries) == 1 |
| 96 | |
| 97 | entry = entries[0] |
| 98 | assert entry['level'] == 'ERROR' |
| 99 | assert entry['message'] == 'Something failed' |
| 100 | assert entry['method'] == 'POST' |
| 101 | assert entry['user_id'] == 'user-123' |
| 102 | assert entry['request_id'] == 'req-456' |
| 103 | |
| 104 | # Timestamp should be between before and after |
| 105 | timestamp = datetime.fromisoformat(entry['timestamp']) |
| 106 | assert before <= timestamp <= after |
| 107 | |
| 108 | def test_logs_for_different_objects_separate(self): |
| 109 | """Should keep logs separate for different objects""" |
| 110 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 111 | |
| 112 | logger1 = SelfLogger(object_id='endpoint1', base_dir=self.temp_dir) |
| 113 | logger2 = SelfLogger(object_id='endpoint2', base_dir=self.temp_dir) |
| 114 | |
| 115 | logger1.log(level='INFO', message='Log from endpoint1') |
| 116 | logger2.log(level='INFO', message='Log from endpoint2') |
| 117 | |
| 118 | # Check separate files |
| 119 | log1 = self.temp_dir / 'logs' / 'endpoint1' / 'log.tsv' |
| 120 | log2 = self.temp_dir / 'logs' / 'endpoint2' / 'log.tsv' |
| 121 | |
| 122 | assert log1.exists() |
| 123 | assert log2.exists() |
| 124 | |
| 125 | # Check content |
| 126 | entries1 = logger1.get_logs() |
| 127 | entries2 = logger2.get_logs() |
| 128 | |
| 129 | assert len(entries1) == 1 |
| 130 | assert len(entries2) == 1 |
| 131 | assert entries1[0]['message'] == 'Log from endpoint1' |
| 132 | assert entries2[0]['message'] == 'Log from endpoint2' |
| 133 | |
| 134 | |
| 135 | class TestLogLevels: |
| 136 | """Test different log levels""" |
| 137 | |
| 138 | def setup_method(self): |
| 139 | """Create temporary directory for each test""" |
| 140 | self.temp_dir = Path(tempfile.mkdtemp()) |
| 141 | |
| 142 | def teardown_method(self): |
| 143 | """Clean up temporary directory""" |
| 144 | if self.temp_dir.exists(): |
| 145 | shutil.rmtree(self.temp_dir) |
| 146 | |
| 147 | def test_log_levels(self): |
| 148 | """Should support different log levels""" |
| 149 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 150 | |
| 151 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 152 | |
| 153 | logger.log(level='DEBUG', message='Debug message') |
| 154 | logger.log(level='INFO', message='Info message') |
| 155 | logger.log(level='WARNING', message='Warning message') |
| 156 | logger.log(level='ERROR', message='Error message') |
| 157 | logger.log(level='CRITICAL', message='Critical message') |
| 158 | |
| 159 | entries = logger.get_logs() |
| 160 | assert len(entries) == 5 |
| 161 | |
| 162 | assert entries[0]['level'] == 'DEBUG' |
| 163 | assert entries[1]['level'] == 'INFO' |
| 164 | assert entries[2]['level'] == 'WARNING' |
| 165 | assert entries[3]['level'] == 'ERROR' |
| 166 | assert entries[4]['level'] == 'CRITICAL' |
| 167 | |
| 168 | def test_convenience_methods(self): |
| 169 | """Should provide convenience methods for each level""" |
| 170 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 171 | |
| 172 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 173 | |
| 174 | logger.debug('Debug message') |
| 175 | logger.info('Info message') |
| 176 | logger.warning('Warning message') |
| 177 | logger.error('Error message') |
| 178 | logger.critical('Critical message') |
| 179 | |
| 180 | entries = logger.get_logs() |
| 181 | assert len(entries) == 5 |
| 182 | |
| 183 | levels = [e['level'] for e in entries] |
| 184 | assert levels == ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] |
| 185 | |
| 186 | |
| 187 | class TestLogQuerying: |
| 188 | """Test querying and filtering logs""" |
| 189 | |
| 190 | def setup_method(self): |
| 191 | """Create temporary directory and some logs""" |
| 192 | self.temp_dir = Path(tempfile.mkdtemp()) |
| 193 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 194 | |
| 195 | self.logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 196 | |
| 197 | # Create some logs |
| 198 | self.logger.info('First message', user_id='user-1') |
| 199 | self.logger.warning('Second message', user_id='user-2') |
| 200 | self.logger.error('Third message', user_id='user-1') |
| 201 | self.logger.info('Fourth message', user_id='user-3') |
| 202 | self.logger.critical('Fifth message', user_id='user-2') |
| 203 | |
| 204 | def teardown_method(self): |
| 205 | """Clean up temporary directory""" |
| 206 | if self.temp_dir.exists(): |
| 207 | shutil.rmtree(self.temp_dir) |
| 208 | |
| 209 | def test_get_all_logs(self): |
| 210 | """Should retrieve all logs""" |
| 211 | entries = self.logger.get_logs() |
| 212 | assert len(entries) == 5 |
| 213 | |
| 214 | def test_filter_by_level(self): |
| 215 | """Should filter logs by level""" |
| 216 | entries = self.logger.get_logs(level='ERROR') |
| 217 | assert len(entries) == 1 |
| 218 | assert entries[0]['message'] == 'Third message' |
| 219 | |
| 220 | def test_filter_by_multiple_levels(self): |
| 221 | """Should filter by multiple levels""" |
| 222 | entries = self.logger.get_logs(level=['ERROR', 'CRITICAL']) |
| 223 | assert len(entries) == 2 |
| 224 | assert entries[0]['level'] in ['ERROR', 'CRITICAL'] |
| 225 | assert entries[1]['level'] in ['ERROR', 'CRITICAL'] |
| 226 | |
| 227 | def test_limit_results(self): |
| 228 | """Should limit number of results""" |
| 229 | entries = self.logger.get_logs(limit=3) |
| 230 | assert len(entries) == 3 |
| 231 | |
| 232 | def test_offset_results(self): |
| 233 | """Should skip entries with offset""" |
| 234 | entries = self.logger.get_logs(offset=2, limit=2) |
| 235 | assert len(entries) == 2 |
| 236 | # Should get 3rd and 4th entries |
| 237 | assert entries[0]['message'] == 'Third message' |
| 238 | assert entries[1]['message'] == 'Fourth message' |
| 239 | |
| 240 | def test_filter_by_custom_field(self): |
| 241 | """Should filter by custom fields like user_id""" |
| 242 | entries = self.logger.get_logs(user_id='user-1') |
| 243 | assert len(entries) == 2 |
| 244 | assert all(e['user_id'] == 'user-1' for e in entries) |
| 245 | |
| 246 | |
| 247 | class TestLogRotation: |
| 248 | """Test log rotation (prevent files from growing too large)""" |
| 249 | |
| 250 | def setup_method(self): |
| 251 | """Create temporary directory for each test""" |
| 252 | self.temp_dir = Path(tempfile.mkdtemp()) |
| 253 | |
| 254 | def teardown_method(self): |
| 255 | """Clean up temporary directory""" |
| 256 | if self.temp_dir.exists(): |
| 257 | shutil.rmtree(self.temp_dir) |
| 258 | |
| 259 | def test_rotation_after_size_limit(self): |
| 260 | """Should rotate log file when it exceeds size limit""" |
| 261 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 262 | |
| 263 | # Create logger with small max size (1KB for testing) |
| 264 | logger = SelfLogger( |
| 265 | object_id='test', |
| 266 | base_dir=self.temp_dir, |
| 267 | max_log_size=1024, # 1KB |
| 268 | ) |
| 269 | |
| 270 | # Write enough logs to exceed 1KB |
| 271 | for i in range(100): |
| 272 | logger.info(f'Log entry {i}' * 10) # Make entries larger |
| 273 | |
| 274 | # Should have rotated to a new file |
| 275 | log_dir = self.temp_dir / 'logs' / 'test' |
| 276 | log_files = list(log_dir.glob('log*.tsv')) |
| 277 | |
| 278 | # Should have multiple log files |
| 279 | assert len(log_files) >= 2 |
| 280 | |
| 281 | def test_rotation_preserves_old_logs(self): |
| 282 | """Should keep old rotated logs""" |
| 283 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 284 | |
| 285 | logger = SelfLogger( |
| 286 | object_id='test', |
| 287 | base_dir=self.temp_dir, |
| 288 | max_log_size=1024, |
| 289 | ) |
| 290 | |
| 291 | # Write logs |
| 292 | for i in range(50): |
| 293 | logger.info(f'First batch {i}' * 10) |
| 294 | |
| 295 | # Get current log file count |
| 296 | log_dir = self.temp_dir / 'logs' / 'test' |
| 297 | files_after_first = list(log_dir.glob('log*.tsv')) |
| 298 | |
| 299 | # Write more logs |
| 300 | for i in range(50): |
| 301 | logger.info(f'Second batch {i}' * 10) |
| 302 | |
| 303 | files_after_second = list(log_dir.glob('log*.tsv')) |
| 304 | |
| 305 | # Should have more files now |
| 306 | assert len(files_after_second) >= len(files_after_first) |
| 307 | |
| 308 | def test_rotation_naming_convention(self): |
| 309 | """Should use timestamp-based naming for rotated logs""" |
| 310 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 311 | |
| 312 | logger = SelfLogger( |
| 313 | object_id='test', |
| 314 | base_dir=self.temp_dir, |
| 315 | max_log_size=512, |
| 316 | ) |
| 317 | |
| 318 | # Write enough to rotate |
| 319 | for i in range(100): |
| 320 | logger.info(f'Entry {i}' * 10) |
| 321 | |
| 322 | log_dir = self.temp_dir / 'logs' / 'test' |
| 323 | log_files = sorted(log_dir.glob('log*.tsv')) |
| 324 | |
| 325 | # Should have log.tsv and log-TIMESTAMP.tsv files |
| 326 | assert any(f.name == 'log.tsv' for f in log_files) |
| 327 | assert any('log-' in f.name and f.name != 'log.tsv' for f in log_files) |
| 328 | |
| 329 | |
| 330 | class TestLogStorage: |
| 331 | """Test log storage format (TSV)""" |
| 332 | |
| 333 | def setup_method(self): |
| 334 | """Create temporary directory for each test""" |
| 335 | self.temp_dir = Path(tempfile.mkdtemp()) |
| 336 | |
| 337 | def teardown_method(self): |
| 338 | """Clean up temporary directory""" |
| 339 | if self.temp_dir.exists(): |
| 340 | shutil.rmtree(self.temp_dir) |
| 341 | |
| 342 | def test_tsv_format(self): |
| 343 | """Should store logs in TSV format""" |
| 344 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 345 | |
| 346 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 347 | logger.info('Test message', custom_field='custom_value') |
| 348 | |
| 349 | log_file = self.temp_dir / 'logs' / 'test' / 'log.tsv' |
| 350 | content = log_file.read_text() |
| 351 | |
| 352 | # Should be tab-separated |
| 353 | assert '\t' in content |
| 354 | # Should have header |
| 355 | lines = content.strip().split('\n') |
| 356 | assert len(lines) == 2 # Header + 1 entry |
| 357 | |
| 358 | def test_human_readable(self): |
| 359 | """Should be human-readable (cat, grep, etc.)""" |
| 360 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 361 | |
| 362 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 363 | logger.error('Error occurred', error_code='E123') |
| 364 | |
| 365 | log_file = self.temp_dir / 'logs' / 'test' / 'log.tsv' |
| 366 | content = log_file.read_text() |
| 367 | |
| 368 | # Should contain the message in plain text |
| 369 | assert 'Error occurred' in content |
| 370 | assert 'E123' in content |
| 371 | # Should be readable (no binary, no JSON escaping) |
| 372 | assert content.isprintable() or '\n' in content or '\t' in content |
| 373 | |
| 374 | def test_append_only(self): |
| 375 | """Should append entries (not overwrite)""" |
| 376 | from dbbasic_object_core.core.self_logger import SelfLogger |
| 377 | |
| 378 | logger = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 379 | |
| 380 | logger.info('First') |
| 381 | logger.info('Second') |
| 382 | |
| 383 | # Create new logger instance (simulates restart) |
| 384 | logger2 = SelfLogger(object_id='test', base_dir=self.temp_dir) |
| 385 | logger2.info('Third') |
| 386 | |
| 387 | entries = logger2.get_logs() |
| 388 | assert len(entries) == 3 |
| 389 | assert entries[0]['message'] == 'First' |
| 390 | assert entries[1]['message'] == 'Second' |
| 391 | assert entries[2]['message'] == 'Third' |