Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tests /test_brain.py
| """ | |
| Tests for brain.py | |
| ================== | |
| Unit tests for the BrainManager and BrainEntry classes. | |
| """ | |
| import json | |
| from datetime import datetime | |
| from pathlib import Path | |
| import pytest | |
| class TestBrainEntry: | |
| """Tests for BrainEntry dataclass.""" | |
| def test_create_entry_minimal(self): | |
| """Should create entry with minimal fields.""" | |
| from brain import BrainEntry | |
| entry = BrainEntry(id="test-001", type="pattern", content="Test pattern") | |
| assert entry.id == "test-001" | |
| assert entry.type == "pattern" | |
| assert entry.content == "Test pattern" | |
| assert entry.context == "" | |
| assert entry.status == "TESTED" | |
| assert entry.tags == [] | |
| assert entry.references == 0 | |
| def test_create_entry_full(self): | |
| """Should create entry with all fields.""" | |
| from brain import BrainEntry | |
| entry = BrainEntry( | |
| id="test-002", | |
| type="lesson", | |
| content="Test lesson", | |
| context="Testing context", | |
| status="EXPERIMENTAL", | |
| tags=["test", "lesson"], | |
| references=5, | |
| date_added="2025-01-01", | |
| date_updated="2025-01-02", | |
| ) | |
| assert entry.id == "test-002" | |
| assert entry.type == "lesson" | |
| assert entry.content == "Test lesson" | |
| assert entry.context == "Testing context" | |
| assert entry.status == "EXPERIMENTAL" | |
| assert entry.tags == ["test", "lesson"] | |
| assert entry.references == 5 | |
| assert entry.date_added == "2025-01-01" | |
| assert entry.date_updated == "2025-01-02" | |
| def test_post_init_dates(self): | |
| """Should auto-generate dates when not provided.""" | |
| from brain import BrainEntry | |
| entry = BrainEntry(id="test-003", type="tip", content="Test tip") | |
| today = datetime.now().strftime("%Y-%m-%d") | |
| assert entry.date_added == today | |
| assert entry.date_updated == today | |
| def test_post_init_date_updated_uses_added(self): | |
| """Should use date_added for date_updated when not provided.""" | |
| from brain import BrainEntry | |
| entry = BrainEntry( | |
| id="test-004", | |
| type="insight", | |
| content="Test insight", | |
| date_added="2025-01-15", | |
| ) | |
| assert entry.date_added == "2025-01-15" | |
| assert entry.date_updated == "2025-01-15" | |
| def test_to_dict(self): | |
| """Should convert entry to dictionary.""" | |
| from brain import BrainEntry | |
| entry = BrainEntry( | |
| id="test-005", | |
| type="antipattern", | |
| content="Don't do this", | |
| tags=["bad"], | |
| ) | |
| result = entry.to_dict() | |
| assert isinstance(result, dict) | |
| assert result["id"] == "test-005" | |
| assert result["type"] == "antipattern" | |
| assert result["content"] == "Don't do this" | |
| assert result["tags"] == ["bad"] | |
| def test_from_dict(self): | |
| """Should create entry from dictionary.""" | |
| from brain import BrainEntry | |
| data = { | |
| "id": "test-006", | |
| "type": "experiment", | |
| "content": "Try this", | |
| "context": "Testing", | |
| "status": "TESTED", | |
| "tags": ["test"], | |
| "references": 3, | |
| "date_added": "2025-01-01", | |
| "date_updated": "2025-01-02", | |
| } | |
| entry = BrainEntry.from_dict(data) | |
| assert entry.id == "test-006" | |
| assert entry.type == "experiment" | |
| assert entry.content == "Try this" | |
| assert entry.context == "Testing" | |
| assert entry.status == "TESTED" | |
| assert entry.tags == ["test"] | |
| assert entry.references == 3 | |
| assert entry.date_added == "2025-01-01" | |
| assert entry.date_updated == "2025-01-02" | |
| def test_from_dict_filters_unknown_fields(self): | |
| """Should ignore unknown fields when creating from dict.""" | |
| from brain import BrainEntry | |
| data = { | |
| "id": "test-007", | |
| "type": "pattern", | |
| "content": "Test", | |
| "unknown_field": "should be ignored", | |
| "another_unknown": 123, | |
| } | |
| entry = BrainEntry.from_dict(data) | |
| assert entry.id == "test-007" | |
| assert not hasattr(entry, "unknown_field") | |
| assert not hasattr(entry, "another_unknown") | |
| class TestBrainManager: | |
| """Tests for BrainManager class.""" | |
| def test_init_with_temp_root(self, temp_mywork_root): | |
| """Should initialize with custom root.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| assert manager.root == temp_mywork_root | |
| assert manager.brain_file == temp_mywork_root / ".planning" / "BRAIN.md" | |
| assert manager.brain_json == temp_mywork_root / ".planning" / "brain_data.json" | |
| def test_load_from_json(self, temp_mywork_root): | |
| """Should load entries from JSON file.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| # Create sample brain data | |
| brain_data = { | |
| "version": "1.0", | |
| "entries": [ | |
| { | |
| "id": "test-001", | |
| "type": "pattern", | |
| "content": "Test pattern", | |
| "status": "TESTED", | |
| "tags": [], | |
| "references": 0, | |
| "date_added": "2025-01-01", | |
| "date_updated": "2025-01-01", | |
| } | |
| ], | |
| } | |
| brain_file = temp_mywork_root / ".planning" / "brain_data.json" | |
| brain_file.write_text(json.dumps(brain_data, indent=2)) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| assert len(manager.entries) == 1 | |
| assert "test-001" in manager.entries | |
| assert manager.entries["test-001"].content == "Test pattern" | |
| def test_save_to_json(self, temp_mywork_root): | |
| """Should save entries to JSON file.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| entry = brain.BrainEntry(id="test-001", type="tip", content="Save test") | |
| manager.entries["test-001"] = entry | |
| manager.save() | |
| brain_file = temp_mywork_root / ".planning" / "brain_data.json" | |
| assert brain_file.exists() | |
| with open(brain_file) as f: | |
| data = json.load(f) | |
| assert data["entry_count"] == 1 | |
| assert len(data["entries"]) == 1 | |
| assert data["entries"][0]["id"] == "test-001" | |
| def test_generate_id(self, temp_mywork_root): | |
| """Should generate unique IDs for entries.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| # First entry | |
| id1 = manager.generate_id("pattern") | |
| assert id1 == "pattern-001" | |
| # Add entry and test second ID | |
| entry = brain.BrainEntry(id=id1, type="pattern", content="Test") | |
| manager.entries[id1] = entry | |
| id2 = manager.generate_id("pattern") | |
| assert id2 == "pattern-002" | |
| def test_add_entry(self, temp_mywork_root): | |
| """Should add new entry to brain.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| entry = manager.add( | |
| "pattern", | |
| "Always validate inputs", | |
| context="API development", | |
| tags=["api", "validation"], | |
| ) | |
| assert entry.id == "pattern-001" | |
| assert entry.type == "pattern" | |
| assert entry.content == "Always validate inputs" | |
| assert entry.context == "API development" | |
| assert entry.tags == ["api", "validation"] | |
| assert entry.status == "TESTED" | |
| assert "pattern-001" in manager.entries | |
| def test_add_invalid_type(self, temp_mywork_root): | |
| """Should raise error for invalid entry type.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| with pytest.raises(ValueError, match="Unknown type"): | |
| manager.add("invalid_type", "Test content") | |
| def test_update_entry(self, temp_mywork_root): | |
| """Should update existing entry.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| entry = manager.add("lesson", "Original content") | |
| updated = manager.update( | |
| entry.id, | |
| content="Updated content", | |
| context="New context", | |
| tags=["updated"], | |
| ) | |
| assert updated is not None | |
| assert updated.content == "Updated content" | |
| assert updated.context == "New context" | |
| assert updated.tags == ["updated"] | |
| def test_update_nonexistent_entry(self, temp_mywork_root): | |
| """Should return None for nonexistent entry.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| result = manager.update("nonexistent-001", content="Test") | |
| assert result is None | |
| def test_deprecate_entry(self, temp_mywork_root): | |
| """Should deprecate an entry.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| entry = manager.add("pattern", "Test pattern") | |
| deprecated = manager.deprecate(entry.id) | |
| assert deprecated is not None | |
| assert deprecated.status == "DEPRECATED" | |
| def test_search_entries(self, temp_mywork_root): | |
| """Should search entries by query.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| manager.add("pattern", "Always validate API inputs") | |
| manager.add("lesson", "Use TypeScript for APIs") | |
| manager.add("tip", "Run tests before deployment") | |
| results = manager.search("API") | |
| assert len(results) == 2 | |
| def test_get_stats(self, temp_mywork_root): | |
| """Should return brain statistics.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| manager.add("pattern", "Test pattern") | |
| manager.add("lesson", "Test lesson") | |
| manager.add("tip", "Test tip") | |
| stats = manager.get_stats() | |
| assert "total_entries" in stats | |
| assert stats["total_entries"] == 3 | |
| assert "by_type" in stats | |
| assert stats["by_type"]["pattern"] == 1 | |
| assert stats["by_type"]["lesson"] == 1 | |
| assert stats["by_type"]["tip"] == 1 | |
| def test_get_experimental(self, temp_mywork_root): | |
| """Should filter entries by experimental status.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| manager.add("pattern", "Test 1", status="TESTED") | |
| manager.add("lesson", "Test 2", status="EXPERIMENTAL") | |
| manager.add("tip", "Test 3", status="TESTED") | |
| experimental = manager.get_experimental() | |
| assert len(experimental) == 1 | |
| assert all(e.status == "EXPERIMENTAL" for e in experimental) | |
| def test_get_deprecated(self, temp_mywork_root): | |
| """Should filter entries by deprecated status.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| manager = brain.BrainManager(root=temp_mywork_root) | |
| entry1 = manager.add("pattern", "Test 1") | |
| entry2 = manager.add("lesson", "Test 2") | |
| # Deprecate one entry | |
| manager.deprecate(entry1.id) | |
| deprecated = manager.get_deprecated() | |
| assert len(deprecated) == 1 | |
| assert deprecated[0].id == entry1.id | |
| assert all(e.status == "DEPRECATED" for e in deprecated) | |
| class TestEntryTypes: | |
| """Tests for ENTRY_TYPES constant.""" | |
| def test_entry_types_defined(self): | |
| """Should have all expected entry types defined.""" | |
| from brain import ENTRY_TYPES | |
| expected_types = ["lesson", "pattern", "antipattern", "tip", "insight", "experiment"] | |
| for entry_type in expected_types: | |
| assert entry_type in ENTRY_TYPES | |
| assert ENTRY_TYPES[entry_type] # Should have a non-empty section name | |
| def test_entry_type_section_names(self): | |
| """Should have meaningful section names for each type.""" | |
| from brain import ENTRY_TYPES | |
| assert "Patterns" in ENTRY_TYPES["pattern"] | |
| assert "Lessons" in ENTRY_TYPES["lesson"] | |
| assert "Anti-Patterns" in ENTRY_TYPES["antipattern"] | |
| assert "Tool" in ENTRY_TYPES["tip"] | |
| assert "Insight" in ENTRY_TYPES["insight"] | |
| assert "Experiment" in ENTRY_TYPES["experiment"] | |
| class TestResolveBrainPaths: | |
| """Tests for _resolve_brain_paths function.""" | |
| def test_resolve_paths_with_custom_root(self, temp_mywork_root): | |
| """Should resolve paths with custom root.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| root, brain_file, brain_json = brain._resolve_brain_paths(temp_mywork_root) | |
| assert root == temp_mywork_root | |
| assert brain_file == temp_mywork_root / ".planning" / "BRAIN.md" | |
| assert brain_json == temp_mywork_root / ".planning" / "brain_data.json" | |
| def test_resolve_paths_without_root(self): | |
| """Should resolve paths using default detection.""" | |
| import importlib | |
| import brain | |
| importlib.reload(brain) | |
| root, brain_file, brain_json = brain._resolve_brain_paths() | |
| assert isinstance(root, Path) | |
| assert isinstance(brain_file, Path) | |
| assert isinstance(brain_json, Path) | |
| assert "BRAIN.md" in str(brain_file) | |
| assert "brain_data.json" in str(brain_json) | |
Xet Storage Details
- Size:
- 14.1 kB
- Xet hash:
- 4a1ae792f31ad76fc87e5a25f4832015196b49266c435025ea990898ce53d807
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.