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

0 downloads

dbbasic-object-primitive/tests/unit/test_version_manager.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_version_manager.py · 11.8 KB · 339 lines
1"""
2Unit tests for version_manager
3
4Test-Driven Development: These tests are written FIRST, before implementation.
5They define the expected behavior of version management.
6
7Every change to an endpoint should be versioned:
8- Before modification, save current version
9- Store metadata (timestamp, author, message, hash)
10- Can retrieve any historical version
11- Can rollback to previous version
12"""
13
14import pytest
15import tempfile
16import shutil
17from pathlib import Path
18from datetime import datetime
19
20
21class TestVersionSaving:
22 """Test saving versions"""
23
24 def setup_method(self):
25 """Create temporary directory for each test"""
26 self.temp_dir = Path(tempfile.mkdtemp())
27
28 def teardown_method(self):
29 """Clean up temporary directory"""
30 if self.temp_dir.exists():
31 shutil.rmtree(self.temp_dir)
32
33 def test_save_first_version(self):
34 """Should save the first version of content"""
35 from dbbasic_object_core.core.version_manager import VersionManager
36
37 vm = VersionManager(self.temp_dir)
38
39 content = "def GET(request): return {'message': 'v1'}"
40 version_id = vm.save_version(
41 object_id='test_endpoint',
42 content=content,
43 author='test_user',
44 message='Initial version',
45 )
46
47 assert version_id is not None
48 assert version_id == 1 # First version
49
50 def test_save_multiple_versions(self):
51 """Should save multiple versions with incrementing IDs"""
52 from dbbasic_object_core.core.version_manager import VersionManager
53
54 vm = VersionManager(self.temp_dir)
55
56 v1 = vm.save_version('test', 'content v1', 'user', 'Version 1')
57 v2 = vm.save_version('test', 'content v2', 'user', 'Version 2')
58 v3 = vm.save_version('test', 'content v3', 'user', 'Version 3')
59
60 assert v1 == 1
61 assert v2 == 2
62 assert v3 == 3
63
64 def test_save_version_with_metadata(self):
65 """Should store metadata with version"""
66 from dbbasic_object_core.core.version_manager import VersionManager
67
68 vm = VersionManager(self.temp_dir)
69
70 before = datetime.now()
71 version_id = vm.save_version(
72 object_id='test',
73 content='test content',
74 author='claude',
75 message='Test commit',
76 )
77 after = datetime.now()
78
79 # Get the version back
80 version = vm.get_version('test', version_id)
81
82 assert version['content'] == 'test content'
83 assert version['author'] == 'claude'
84 assert version['message'] == 'Test commit'
85 assert 'timestamp' in version
86 assert 'hash' in version
87
88 # Timestamp should be between before and after
89 timestamp = datetime.fromisoformat(version['timestamp'])
90 assert before <= timestamp <= after
91
92 def test_content_hash_changes_with_content(self):
93 """Should compute different hashes for different content"""
94 from dbbasic_object_core.core.version_manager import VersionManager
95
96 vm = VersionManager(self.temp_dir)
97
98 v1 = vm.save_version('test', 'content 1', 'user', 'v1')
99 v2 = vm.save_version('test', 'content 2', 'user', 'v2')
100
101 ver1 = vm.get_version('test', v1)
102 ver2 = vm.get_version('test', v2)
103
104 # Hashes should be different
105 assert ver1['hash'] != ver2['hash']
106
107 def test_save_version_for_different_objects(self):
108 """Should handle versions for different objects independently"""
109 from dbbasic_object_core.core.version_manager import VersionManager
110
111 vm = VersionManager(self.temp_dir)
112
113 # Save versions for two different objects
114 obj1_v1 = vm.save_version('object1', 'content1', 'user', 'obj1 v1')
115 obj2_v1 = vm.save_version('object2', 'content2', 'user', 'obj2 v1')
116 obj1_v2 = vm.save_version('object1', 'content1-v2', 'user', 'obj1 v2')
117
118 # Both should start at version 1
119 assert obj1_v1 == 1
120 assert obj2_v1 == 1
121 assert obj1_v2 == 2
122
123
124class TestVersionRetrieval:
125 """Test retrieving versions"""
126
127 def setup_method(self):
128 """Create temporary directory and save some versions"""
129 self.temp_dir = Path(tempfile.mkdtemp())
130 from dbbasic_object_core.core.version_manager import VersionManager
131
132 self.vm = VersionManager(self.temp_dir)
133
134 # Save some versions
135 self.v1 = self.vm.save_version('test', 'content v1', 'user1', 'First version')
136 self.v2 = self.vm.save_version('test', 'content v2', 'user2', 'Second version')
137 self.v3 = self.vm.save_version('test', 'content v3', 'user3', 'Third version')
138
139 def teardown_method(self):
140 """Clean up temporary directory"""
141 if self.temp_dir.exists():
142 shutil.rmtree(self.temp_dir)
143
144 def test_get_specific_version(self):
145 """Should retrieve a specific version by ID"""
146 version = self.vm.get_version('test', self.v2)
147
148 assert version['content'] == 'content v2'
149 assert version['author'] == 'user2'
150 assert version['message'] == 'Second version'
151 assert version['version_id'] == self.v2
152
153 def test_get_latest_version(self):
154 """Should get latest version when version_id=None"""
155 version = self.vm.get_version('test')
156
157 assert version['content'] == 'content v3'
158 assert version['author'] == 'user3'
159 assert version['version_id'] == self.v3
160
161 def test_get_nonexistent_version_returns_none(self):
162 """Should return None for non-existent version"""
163 version = self.vm.get_version('test', 999)
164
165 assert version is None
166
167 def test_get_version_for_nonexistent_object_returns_none(self):
168 """Should return None for non-existent object"""
169 version = self.vm.get_version('nonexistent_object')
170
171 assert version is None
172
173
174class TestVersionHistory:
175 """Test version history listing"""
176
177 def setup_method(self):
178 """Create temporary directory and save some versions"""
179 self.temp_dir = Path(tempfile.mkdtemp())
180 from dbbasic_object_core.core.version_manager import VersionManager
181
182 self.vm = VersionManager(self.temp_dir)
183
184 # Save multiple versions
185 for i in range(1, 6):
186 self.vm.save_version('test', f'content v{i}', f'user{i}', f'Version {i}')
187
188 def teardown_method(self):
189 """Clean up temporary directory"""
190 if self.temp_dir.exists():
191 shutil.rmtree(self.temp_dir)
192
193 def test_get_all_versions(self):
194 """Should return all versions in order (newest first, like git log)"""
195 history = self.vm.get_history('test')
196
197 assert len(history) == 5
198 assert history[0]['version_id'] == 5 # Newest first
199 assert history[4]['version_id'] == 1 # Oldest last
200
201 def test_get_limited_history(self):
202 """Should limit number of versions returned"""
203 history = self.vm.get_history('test', limit=3)
204
205 assert len(history) == 3
206 # Should return most recent 3
207 assert history[0]['version_id'] == 5
208 assert history[1]['version_id'] == 4
209 assert history[2]['version_id'] == 3
210
211 def test_get_history_with_offset(self):
212 """Should skip versions with offset"""
213 history = self.vm.get_history('test', offset=2, limit=2)
214
215 assert len(history) == 2
216 # Skip 2 most recent (5, 4), get next 2 (3, 2)
217 assert history[0]['version_id'] == 3
218 assert history[1]['version_id'] == 2
219
220 def test_history_includes_metadata_not_content(self):
221 """Should include metadata but not full content in history"""
222 history = self.vm.get_history('test')
223
224 for version in history:
225 assert 'version_id' in version
226 assert 'timestamp' in version
227 assert 'author' in version
228 assert 'message' in version
229 assert 'hash' in version
230 # Content should NOT be in history (only in full version)
231 assert 'content' not in version
232
233
234class TestVersionRollback:
235 """Test rolling back to previous versions"""
236
237 def setup_method(self):
238 """Create temporary directory and save some versions"""
239 self.temp_dir = Path(tempfile.mkdtemp())
240 from dbbasic_object_core.core.version_manager import VersionManager
241
242 self.vm = VersionManager(self.temp_dir)
243
244 # Save 3 versions
245 self.v1 = self.vm.save_version('test', 'content v1', 'user', 'v1')
246 self.v2 = self.vm.save_version('test', 'content v2', 'user', 'v2')
247 self.v3 = self.vm.save_version('test', 'content v3', 'user', 'v3')
248
249 def teardown_method(self):
250 """Clean up temporary directory"""
251 if self.temp_dir.exists():
252 shutil.rmtree(self.temp_dir)
253
254 def test_rollback_to_previous_version(self):
255 """Should rollback to an earlier version"""
256 # Rollback to v1
257 new_version_id = self.vm.rollback('test', to_version=self.v1, author='rollback_user', message='Rollback to v1')
258
259 # Should create a new version (v4)
260 assert new_version_id == 4
261
262 # Content should match v1
263 current = self.vm.get_version('test')
264 assert current['content'] == 'content v1'
265 assert current['version_id'] == 4
266 assert 'Rollback to v1' in current['message']
267
268 def test_rollback_preserves_history(self):
269 """Should preserve all history after rollback"""
270 self.vm.rollback('test', to_version=self.v1, author='user', message='Rollback')
271
272 history = self.vm.get_history('test')
273
274 # Should have 4 versions now (v1, v2, v3, v4=rollback)
275 assert len(history) == 4
276
277 def test_rollback_to_nonexistent_version_raises_error(self):
278 """Should raise error when rolling back to non-existent version"""
279 from dbbasic_object_core.core.version_manager import VersionNotFoundError
280
281 with pytest.raises(VersionNotFoundError):
282 self.vm.rollback('test', to_version=999, author='user', message='Rollback')
283
284
285class TestVersionStorage:
286 """Test how versions are stored (TSV format)"""
287
288 def setup_method(self):
289 """Create temporary directory"""
290 self.temp_dir = Path(tempfile.mkdtemp())
291
292 def teardown_method(self):
293 """Clean up temporary directory"""
294 if self.temp_dir.exists():
295 shutil.rmtree(self.temp_dir)
296
297 def test_creates_version_directory_structure(self):
298 """Should create directory structure for versions"""
299 from dbbasic_object_core.core.version_manager import VersionManager
300
301 vm = VersionManager(self.temp_dir)
302 vm.save_version('test_obj', 'content', 'user', 'message')
303
304 # Should create: versions/test_obj/
305 versions_dir = self.temp_dir / 'versions' / 'test_obj'
306 assert versions_dir.exists()
307 assert versions_dir.is_dir()
308
309 def test_stores_version_metadata_in_tsv(self):
310 """Should store version metadata in TSV file"""
311 from dbbasic_object_core.core.version_manager import VersionManager
312
313 vm = VersionManager(self.temp_dir)
314 vm.save_version('test', 'content', 'user', 'message')
315
316 # Should create metadata TSV
317 metadata_file = self.temp_dir / 'versions' / 'test' / 'metadata.tsv'
318 assert metadata_file.exists()
319
320 # Read the TSV
321 content = metadata_file.read_text()
322 lines = content.strip().split('\n')
323
324 # Should have header + 1 data row
325 assert len(lines) == 2
326 assert 'version_id' in lines[0] # Header
327 assert '\t' in lines[1] # TSV format
328
329 def test_stores_version_content_separately(self):
330 """Should store version content in separate file"""
331 from dbbasic_object_core.core.version_manager import VersionManager
332
333 vm = VersionManager(self.temp_dir)
334 vm.save_version('test', 'test content here', 'user', 'message')
335
336 # Should create content file
337 content_file = self.temp_dir / 'versions' / 'test' / 'v1.txt'
338 assert content_file.exists()
339 assert content_file.read_text() == 'test content here'