| 1 | package control |
| 2 | |
| 3 | import ( |
| 4 | "fmt" |
| 5 | "os" |
| 6 | "path/filepath" |
| 7 | "strings" |
| 8 | "sync" |
| 9 | "testing" |
| 10 | |
| 11 | "reasonix/internal/memory" |
| 12 | ) |
| 13 | |
| 14 | // TestMemoryWriteReflectsInSnapshot verifies that a memory write lands on disk |
| 15 | // and that Memory() returns a freshly reloaded snapshot afterwards — the behavior |
| 16 | // the memoryManager (off-c.mu) extraction must preserve. |
| 17 | func TestMemoryWriteReflectsInSnapshot(t *testing.T) { |
| 18 | dir := t.TempDir() |
| 19 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: dir})}) |
| 20 | |
| 21 | before := c.Memory() |
| 22 | if before == nil { |
| 23 | t.Fatal("memory should be enabled") |
| 24 | } |
| 25 | |
| 26 | path, err := c.QuickAdd(memory.ScopeProject, "prefer tabs over spaces") |
| 27 | if err != nil { |
| 28 | t.Fatalf("QuickAdd: %v", err) |
| 29 | } |
| 30 | |
| 31 | body, err := os.ReadFile(path) |
| 32 | if err != nil { |
| 33 | t.Fatalf("read doc: %v", err) |
| 34 | } |
| 35 | if !strings.Contains(string(body), "prefer tabs over spaces") { |
| 36 | t.Fatalf("note not written to disk:\n%s", body) |
| 37 | } |
| 38 | |
| 39 | after := c.Memory() |
| 40 | if after == nil { |
| 41 | t.Fatal("memory snapshot is nil after QuickAdd") |
| 42 | } |
| 43 | if after == before { |
| 44 | t.Fatal("Memory() returned the stale snapshot; the manager did not swap in a reload") |
| 45 | } |
| 46 | } |
| 47 | |
| 48 | func TestSaveMemoryRefreshesBackgroundSnapshotWithoutLegacyUpdate(t *testing.T) { |
| 49 | root := t.TempDir() |
| 50 | userDir := filepath.Join(root, "user") |
| 51 | cwd := filepath.Join(root, "project") |
| 52 | if err := os.MkdirAll(cwd, 0o755); err != nil { |
| 53 | t.Fatal(err) |
| 54 | } |
| 55 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: cwd, UserDir: userDir})}) |
| 56 | |
| 57 | body := "Always answer in Chinese unless the user explicitly asks for English.\nKeep technical terms precise." |
| 58 | if _, err := c.SaveMemory(memory.Memory{ |
| 59 | Name: "response-language", |
| 60 | Description: "preferred response language", |
| 61 | Type: memory.TypeUser, |
| 62 | Scope: memory.FactScopeGlobal, |
| 63 | Body: body, |
| 64 | }); err != nil { |
| 65 | t.Fatalf("SaveMemory: %v", err) |
| 66 | } |
| 67 | |
| 68 | background := c.Memory().BackgroundDataBlock() |
| 69 | if !strings.Contains(background, "response-language") || !strings.Contains(background, body) { |
| 70 | t.Fatalf("saved memory missing from refreshed background snapshot:\n%s", background) |
| 71 | } |
| 72 | if composed := c.Compose("hello"); strings.Contains(composed, "<memory-update>") || composed != "hello" { |
| 73 | t.Fatalf("background save generated legacy update: %q", composed) |
| 74 | } |
| 75 | } |
| 76 | |
| 77 | func TestForgetMemoryRefreshesBackgroundSnapshotWithoutLegacyUpdate(t *testing.T) { |
| 78 | root := t.TempDir() |
| 79 | userDir := filepath.Join(root, "user") |
| 80 | cwd := filepath.Join(root, "project") |
| 81 | if err := os.MkdirAll(cwd, 0o755); err != nil { |
| 82 | t.Fatal(err) |
| 83 | } |
| 84 | store := memory.StoreFor(userDir, cwd) |
| 85 | const body = "Never use emoji in responses." |
| 86 | if _, err := store.Save(memory.Memory{ |
| 87 | Name: "no-emoji", |
| 88 | Description: "avoid emoji", |
| 89 | Type: memory.TypeFeedback, |
| 90 | Scope: memory.FactScopeGlobal, |
| 91 | Body: body, |
| 92 | }); err != nil { |
| 93 | t.Fatal(err) |
| 94 | } |
| 95 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: cwd, UserDir: userDir})}) |
| 96 | if before := c.Memory().Block(); !strings.Contains(before, body) { |
| 97 | t.Fatalf("test setup did not load global guidance:\n%s", before) |
| 98 | } |
| 99 | |
| 100 | if err := c.ForgetMemory("no-emoji"); err != nil { |
| 101 | t.Fatalf("ForgetMemory: %v", err) |
| 102 | } |
| 103 | if after := c.Memory().Block(); strings.Contains(after, body) { |
| 104 | t.Fatalf("reloaded snapshot retained forgotten global guidance:\n%s", after) |
| 105 | } |
| 106 | composed := c.Compose("hello") |
| 107 | if strings.Contains(composed, "<memory-update>") || composed != "hello" { |
| 108 | t.Fatalf("forget generated legacy update: %q", composed) |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | func TestRestoreArchivedMemoryRefreshesBackgroundSnapshotWithoutLegacyUpdate(t *testing.T) { |
| 113 | root := t.TempDir() |
| 114 | userDir := filepath.Join(root, "user") |
| 115 | cwd := filepath.Join(root, "project") |
| 116 | if err := os.MkdirAll(cwd, 0o755); err != nil { |
| 117 | t.Fatal(err) |
| 118 | } |
| 119 | store := memory.StoreFor(userDir, cwd) |
| 120 | first, err := store.SaveWithOptions(memory.Memory{ |
| 121 | Name: "build-contract", Description: "project build contract", Body: "Run the focused package tests before the full suite.", |
| 122 | }, memory.SaveOptions{}) |
| 123 | if err != nil { |
| 124 | t.Fatal(err) |
| 125 | } |
| 126 | archivePath, err := store.Archive(first.Memory.ID) |
| 127 | if err != nil { |
| 128 | t.Fatal(err) |
| 129 | } |
| 130 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: cwd, UserDir: userDir})}) |
| 131 | |
| 132 | restored, err := c.RestoreArchivedMemory(archivePath) |
| 133 | if err != nil { |
| 134 | t.Fatal(err) |
| 135 | } |
| 136 | if restored.ID != first.Memory.ID || restored.Revision != 2 { |
| 137 | t.Fatalf("restored memory = %+v", restored) |
| 138 | } |
| 139 | background := c.Memory().BackgroundDataBlock() |
| 140 | if !strings.Contains(background, "build-contract") || !strings.Contains(background, "project build contract") { |
| 141 | t.Fatalf("restored memory missing from refreshed background snapshot:\n%s", background) |
| 142 | } |
| 143 | if composed := c.Compose("continue"); strings.Contains(composed, "<memory-update>") || composed != "continue" { |
| 144 | t.Fatalf("archived restore generated legacy update: %q", composed) |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | // TestMemoryWritesConcurrencySafe hammers memory writes from many goroutines |
| 149 | // while c.mu-guarded reads run concurrently. Under -race this proves the |
| 150 | // memoryManager's writeMu/mu split has no data race and no deadlock — and that |
| 151 | // holding writeMu (off c.mu) across the disk I/O still serializes writes so every |
| 152 | // note lands. |
| 153 | func TestMemoryWritesConcurrencySafe(t *testing.T) { |
| 154 | dir := t.TempDir() |
| 155 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: dir})}) |
| 156 | |
| 157 | const writers = 8 |
| 158 | const each = 5 |
| 159 | |
| 160 | stop := make(chan struct{}) |
| 161 | var readers sync.WaitGroup |
| 162 | readers.Go(func() { |
| 163 | for { |
| 164 | select { |
| 165 | case <-stop: |
| 166 | return |
| 167 | default: |
| 168 | _ = c.Running() // takes c.mu |
| 169 | _ = c.RuntimeStatus() // takes c.mu |
| 170 | _ = c.Memory() // takes c.mu, returns the snapshot pointer |
| 171 | } |
| 172 | } |
| 173 | }) |
| 174 | |
| 175 | var writersWG sync.WaitGroup |
| 176 | for w := range writers { |
| 177 | writersWG.Add(1) |
| 178 | go func(w int) { |
| 179 | defer writersWG.Done() |
| 180 | for i := range each { |
| 181 | if _, err := c.QuickAdd(memory.ScopeProject, fmt.Sprintf("note w%d-%d", w, i)); err != nil { |
| 182 | t.Errorf("QuickAdd: %v", err) |
| 183 | } |
| 184 | } |
| 185 | }(w) |
| 186 | } |
| 187 | writersWG.Wait() |
| 188 | close(stop) |
| 189 | readers.Wait() |
| 190 | |
| 191 | body, err := os.ReadFile(c.Memory().DocPath(memory.ScopeProject)) |
| 192 | if err != nil { |
| 193 | t.Fatalf("read doc: %v", err) |
| 194 | } |
| 195 | for w := range writers { |
| 196 | for i := range each { |
| 197 | want := fmt.Sprintf("note w%d-%d", w, i) |
| 198 | if !strings.Contains(string(body), want) { |
| 199 | t.Fatalf("memory doc missing %q after concurrent writes:\n%s", want, body) |
| 200 | } |
| 201 | } |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | func TestRestoreMemoryRefreshesBackgroundSnapshotWithoutLegacyUpdate(t *testing.T) { |
| 206 | dir := t.TempDir() |
| 207 | c := newOwnedTestController(t, Options{Memory: memory.Load(memory.Options{CWD: dir, UserDir: t.TempDir()})}) |
| 208 | store := c.Memory().Store |
| 209 | first, err := store.SaveWithOptions(memory.Memory{Name: "release-target", Description: "v1", Body: "main-v2"}, memory.SaveOptions{}) |
| 210 | if err != nil { |
| 211 | t.Fatal(err) |
| 212 | } |
| 213 | if _, err := store.SaveWithOptions(memory.Memory{ID: first.Memory.ID, Name: "release-target", Description: "v2", Body: "release-v2"}, memory.SaveOptions{}); err != nil { |
| 214 | t.Fatal(err) |
| 215 | } |
| 216 | c.memory.applyWrite(c.Memory(), "") |
| 217 | |
| 218 | restored, err := c.RestoreMemory(first.Memory.ID, 1) |
| 219 | if err != nil { |
| 220 | t.Fatal(err) |
| 221 | } |
| 222 | if restored.Revision != 3 || restored.Body != "main-v2" { |
| 223 | t.Fatalf("restored = %+v", restored) |
| 224 | } |
| 225 | if revisions := c.MemoryRevisions(first.Memory.ID); len(revisions) < 2 { |
| 226 | t.Fatalf("revision history = %+v", revisions) |
| 227 | } |
| 228 | background := c.Memory().BackgroundDataBlock() |
| 229 | if !strings.Contains(background, "release-target") || !strings.Contains(background, "v1") { |
| 230 | t.Fatalf("restored revision missing from refreshed background snapshot: %q", background) |
| 231 | } |
| 232 | if composed := c.Compose("continue"); strings.Contains(composed, "<memory-update>") || composed != "continue" { |
| 233 | t.Fatalf("revision restore generated legacy update: %q", composed) |
| 234 | } |
| 235 | } |
| 236 |