Test
87ceea3d30
- Add internal/indexing package for lessons index - Implement LessonIndex with multi-field index structure - Index by task type, activity type, failure type, and pattern - Fast lookups: O(1) map access for all query types - Build from JSONL file with streaming parse - Support incremental lesson addition - Query operations with optional AND logic - Time range queries for temporal analysis - Similarity search by failure message substring - Most frequent failures ranking - 20 indexing tests, all passing Features: - FindByTaskType() - query by task type - FindByActivityType() - query by activity type - FindByFailureType() - query by failure type - FindByPattern() - query by pattern - FindSimilar() - substring search in failure messages - QueryMultiple() - AND logic for multi-field queries - GetByTimeRange() - temporal range queries - GetMostFrequentFailures() - ranked by frequency - BuildFromFile() - load from JSONL - AddLesson() - incremental updates Performance Verified: - Lookup < 10ms for 1000s entries ✓ - <10ms for 10,000 entries ✓ - Concurrent queries supported ✓ - O(1) average lookup complexity - Index rebuilding efficient Test Coverage: - 20 indexing tests (build, query, range, stats) - Latency verification (< 10ms) - Concurrency testing - Time range queries - Multi-field queries - Large dataset support (10k entries) Index Structures: - lessons: ID -> Lesson (full lookup) - byTaskType: TaskType -> []*Lesson - byActivityType: ActivityType -> []*Lesson - byFailureType: FailureType -> []*Lesson - byPattern: Pattern -> []*Lesson - All RWMutex-protected for thread safety Next: T2.5 (Git operation batching)
468 lines
11 KiB
Go
468 lines
11 KiB
Go
package indexing
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func createTestLessonsFile(t *testing.T, count int) string {
|
|
file, err := os.CreateTemp("", "lessons-*.jsonl")
|
|
assert.NoError(t, err)
|
|
defer file.Close()
|
|
|
|
for i := 0; i < count; i++ {
|
|
lesson := Lesson{
|
|
ID: "lesson-" + string(rune(48+i%10)) + "-" + string(rune(48+i/10)),
|
|
TaskType: []string{"add_feature", "fix_bug", "refactor"}[i%3],
|
|
ActivityType: []string{"implementer", "judge", "planner"}[i%3],
|
|
FailureType: []string{"syntax_error", "logic_error", "timeout"}[i%3],
|
|
FailureMsg: "Error message " + string(rune(48+i%100)),
|
|
Resolution: "Fix strategy",
|
|
Pattern: "pattern-" + string(rune(48+i%5)),
|
|
TimesSeen: i % 10,
|
|
LastSeen: time.Now().Add(-time.Duration(i) * time.Hour),
|
|
FirstSeen: time.Now().Add(-time.Duration(i*24) * time.Hour),
|
|
Metadata: map[string]interface{}{
|
|
"index": i,
|
|
},
|
|
}
|
|
|
|
data, _ := json.Marshal(lesson)
|
|
file.WriteString(string(data) + "\n")
|
|
}
|
|
|
|
return file.Name()
|
|
}
|
|
|
|
|
|
|
|
func TestNewLessonIndex(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
assert.NotNil(t, index)
|
|
assert.Equal(t, 0, index.Count())
|
|
}
|
|
|
|
func TestBuildFromFile(t *testing.T) {
|
|
file := createTestLessonsFile(t, 50)
|
|
defer os.Remove(file)
|
|
|
|
index := NewLessonIndex()
|
|
err := index.BuildFromFile(file)
|
|
assert.NoError(t, err)
|
|
assert.Greater(t, index.Count(), 0)
|
|
}
|
|
|
|
func TestAddLesson(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lesson := &Lesson{
|
|
ID: "test-1",
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
FailureType: "syntax_error",
|
|
FailureMsg: "Missing semicolon",
|
|
Resolution: "Add semicolon",
|
|
Pattern: "syntax-missing-semi",
|
|
TimesSeen: 1,
|
|
LastSeen: time.Now(),
|
|
FirstSeen: time.Now(),
|
|
}
|
|
|
|
index.AddLesson(lesson)
|
|
assert.Equal(t, 1, index.Count())
|
|
|
|
retrieved, exists := index.GetLesson("test-1")
|
|
assert.True(t, exists)
|
|
assert.Equal(t, "test-1", retrieved.ID)
|
|
}
|
|
|
|
func TestFindByTaskType(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", TaskType: "add_feature", ActivityType: "implementer"},
|
|
{ID: "2", TaskType: "add_feature", ActivityType: "judge"},
|
|
{ID: "3", TaskType: "fix_bug", ActivityType: "implementer"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.FindByTaskType("add_feature")
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestFindByActivityType(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", TaskType: "add_feature", ActivityType: "implementer"},
|
|
{ID: "2", TaskType: "add_feature", ActivityType: "implementer"},
|
|
{ID: "3", TaskType: "fix_bug", ActivityType: "judge"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.FindByActivityType("implementer")
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestFindByFailureType(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", FailureType: "syntax_error"},
|
|
{ID: "2", FailureType: "syntax_error"},
|
|
{ID: "3", FailureType: "logic_error"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.FindByFailureType("syntax_error")
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestFindByPattern(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", Pattern: "pattern-1"},
|
|
{ID: "2", Pattern: "pattern-2"},
|
|
{ID: "3", Pattern: "pattern-1"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.FindByPattern("pattern-1")
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestFindSimilar(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", FailureMsg: "Syntax error: missing semicolon"},
|
|
{ID: "2", FailureMsg: "Logic error: wrong condition"},
|
|
{ID: "3", FailureMsg: "Syntax error: missing bracket"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.FindSimilar("syntax")
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestQueryMultiple(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", TaskType: "add_feature", ActivityType: "implementer", FailureType: "syntax_error"},
|
|
{ID: "2", TaskType: "add_feature", ActivityType: "judge", FailureType: "syntax_error"},
|
|
{ID: "3", TaskType: "fix_bug", ActivityType: "implementer", FailureType: "logic_error"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
results := index.QueryMultiple("add_feature", "implementer", "syntax_error")
|
|
assert.Equal(t, 1, len(results))
|
|
assert.Equal(t, "1", results[0].ID)
|
|
}
|
|
|
|
func TestGetByTimeRange(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
now := time.Now()
|
|
lessons := []*Lesson{
|
|
{ID: "1", LastSeen: now.Add(-2 * time.Hour)},
|
|
{ID: "2", LastSeen: now.Add(-1 * time.Hour)},
|
|
{ID: "3", LastSeen: now.Add(-24 * time.Hour)},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
// Range before any lessons should find 0
|
|
results := index.GetByTimeRange(now.Add(-48*time.Hour), now.Add(-25*time.Hour))
|
|
assert.Equal(t, 0, len(results))
|
|
|
|
// Range that includes all lessons
|
|
results = index.GetByTimeRange(now.Add(-25*time.Hour), now)
|
|
assert.Equal(t, 3, len(results))
|
|
|
|
// Range that includes only recent lessons (1 and 2)
|
|
results = index.GetByTimeRange(now.Add(-3*time.Hour), now)
|
|
assert.Equal(t, 2, len(results))
|
|
}
|
|
|
|
func TestGetStats(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", TaskType: "add_feature", ActivityType: "implementer"},
|
|
{ID: "2", TaskType: "add_feature", ActivityType: "judge"},
|
|
{ID: "3", TaskType: "fix_bug", ActivityType: "implementer"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
stats := index.GetStats()
|
|
assert.Equal(t, 3, stats["total_lessons"])
|
|
assert.Equal(t, 2, stats["unique_task_types"])
|
|
assert.Equal(t, 2, stats["unique_activity_types"])
|
|
}
|
|
|
|
func TestGetAllLessons(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1"},
|
|
{ID: "2"},
|
|
{ID: "3"},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
all := index.GetAllLessons()
|
|
assert.Equal(t, 3, len(all))
|
|
}
|
|
|
|
func TestClear(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
index.AddLesson(&Lesson{ID: "1"})
|
|
index.AddLesson(&Lesson{ID: "2"})
|
|
assert.Equal(t, 2, index.Count())
|
|
|
|
index.Clear()
|
|
assert.Equal(t, 0, index.Count())
|
|
}
|
|
|
|
func TestGetMostFrequentFailures(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lessons := []*Lesson{
|
|
{ID: "1", TimesSeen: 5},
|
|
{ID: "2", TimesSeen: 10},
|
|
{ID: "3", TimesSeen: 3},
|
|
}
|
|
|
|
for _, lesson := range lessons {
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
top := index.GetMostFrequentFailures(2)
|
|
assert.Equal(t, 2, len(top))
|
|
assert.Equal(t, 10, top[0].TimesSeen)
|
|
assert.Equal(t, 5, top[1].TimesSeen)
|
|
}
|
|
|
|
func TestLookupLatency(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
// Add 1000 lessons
|
|
for i := 0; i < 1000; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%100)),
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
FailureType: "syntax_error",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
// Measure lookup time
|
|
start := time.Now()
|
|
results := index.FindByTaskType("add_feature")
|
|
elapsed := time.Since(start)
|
|
|
|
assert.Greater(t, len(results), 0)
|
|
// Should be < 10ms
|
|
assert.Less(t, elapsed, 10*time.Millisecond)
|
|
}
|
|
|
|
func TestLookupLatencyLarge(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
// Add 10000 lessons
|
|
for i := 0; i < 10000; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%100)),
|
|
TaskType: []string{"add_feature", "fix_bug", "refactor"}[i%3],
|
|
ActivityType: []string{"implementer", "judge", "planner"}[i%3],
|
|
FailureType: "syntax_error",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
// Measure lookup time
|
|
start := time.Now()
|
|
results := index.FindByActivityType("implementer")
|
|
elapsed := time.Since(start)
|
|
|
|
assert.Greater(t, len(results), 0)
|
|
// Should be < 10ms even with 10k entries
|
|
assert.Less(t, elapsed, 10*time.Millisecond)
|
|
}
|
|
|
|
func TestConcurrentQueries(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
// Add lessons
|
|
for i := 0; i < 100; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%10)),
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
FailureType: "syntax_error",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
// Run concurrent queries
|
|
done := make(chan bool, 10)
|
|
for i := 0; i < 10; i++ {
|
|
go func() {
|
|
results := index.FindByTaskType("add_feature")
|
|
assert.Greater(t, len(results), 0)
|
|
done <- true
|
|
}()
|
|
}
|
|
|
|
for i := 0; i < 10; i++ {
|
|
<-done
|
|
}
|
|
}
|
|
|
|
func TestEmptyQueries(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
results := index.FindByTaskType("nonexistent")
|
|
assert.Equal(t, 0, len(results))
|
|
|
|
results = index.FindByActivityType("nonexistent")
|
|
assert.Equal(t, 0, len(results))
|
|
|
|
results = index.FindByFailureType("nonexistent")
|
|
assert.Equal(t, 0, len(results))
|
|
}
|
|
|
|
func TestGetLesson(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lesson := &Lesson{ID: "test-1", TaskType: "add_feature"}
|
|
index.AddLesson(lesson)
|
|
|
|
retrieved, exists := index.GetLesson("test-1")
|
|
assert.True(t, exists)
|
|
assert.Equal(t, "test-1", retrieved.ID)
|
|
|
|
_, exists = index.GetLesson("nonexistent")
|
|
assert.False(t, exists)
|
|
}
|
|
|
|
func TestMultipleIndexes(t *testing.T) {
|
|
index := NewLessonIndex()
|
|
|
|
lesson := &Lesson{
|
|
ID: "1",
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
FailureType: "syntax_error",
|
|
Pattern: "pattern-1",
|
|
}
|
|
|
|
index.AddLesson(lesson)
|
|
|
|
// Should be findable by all indexes
|
|
assert.Equal(t, 1, len(index.FindByTaskType("add_feature")))
|
|
assert.Equal(t, 1, len(index.FindByActivityType("implementer")))
|
|
assert.Equal(t, 1, len(index.FindByFailureType("syntax_error")))
|
|
assert.Equal(t, 1, len(index.FindByPattern("pattern-1")))
|
|
}
|
|
|
|
func TestRebuild(t *testing.T) {
|
|
file := createTestLessonsFile(t, 50)
|
|
defer os.Remove(file)
|
|
|
|
index := NewLessonIndex()
|
|
_ = index.BuildFromFile(file)
|
|
count1 := index.Count()
|
|
|
|
_ = index.Rebuild()
|
|
count2 := index.Count()
|
|
|
|
assert.Equal(t, count1, count2)
|
|
}
|
|
|
|
func BenchmarkAddLesson(b *testing.B) {
|
|
index := NewLessonIndex()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%100)),
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
FailureType: "syntax_error",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
}
|
|
|
|
func BenchmarkFindByTaskType(b *testing.B) {
|
|
index := NewLessonIndex()
|
|
|
|
// Populate index
|
|
for i := 0; i < 1000; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%100)),
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
index.FindByTaskType("add_feature")
|
|
}
|
|
}
|
|
|
|
func BenchmarkFindByActivityType(b *testing.B) {
|
|
index := NewLessonIndex()
|
|
|
|
// Populate index
|
|
for i := 0; i < 1000; i++ {
|
|
lesson := &Lesson{
|
|
ID: "lesson-" + string(rune(48+i%100)),
|
|
TaskType: "add_feature",
|
|
ActivityType: "implementer",
|
|
}
|
|
index.AddLesson(lesson)
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
index.FindByActivityType("implementer")
|
|
}
|
|
}
|