Python functions as REST objects, with clustering, load balancing and state replication; no containers or orchestration.

0 downloads

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

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

Dan Q Consolidate duplicate QUICKSTARTs on the top-level file 503f830 7 months ago History
test_self_logging.py · 13.0 KB · 391 lines
1"""
2Unit tests for self-logging pattern
3
4Test-Driven Development: These tests are written FIRST, before implementation.
5They define the expected behavior of self-logging.
6
7Self-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
15import pytest
16import tempfile
17import shutil
18from pathlib import Path
19from datetime import datetime, timedelta
20
21
22class 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
135class 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
187class 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
247class 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
330class 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'