| 1 | package extension |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "encoding/json" |
| 6 | "errors" |
| 7 | "os" |
| 8 | "path/filepath" |
| 9 | "strings" |
| 10 | "testing" |
| 11 | ) |
| 12 | |
| 13 | func TestSessionExtensionsRoundTrip(t *testing.T) { |
| 14 | dir := t.TempDir() |
| 15 | sessionPath := filepath.Join(dir, "session.jsonl") |
| 16 | |
| 17 | store, err := LoadSessionExtensions(sessionPath) |
| 18 | if err != nil { |
| 19 | t.Fatalf("LoadSessionExtensions: %v", err) |
| 20 | } |
| 21 | if _, ok := store.Get("missing"); ok { |
| 22 | t.Fatal("empty store returned a blob") |
| 23 | } |
| 24 | if err := store.Set("alpha", json.RawMessage(`{"count":3,"notes":["a","b"]}`)); err != nil { |
| 25 | t.Fatalf("Set alpha: %v", err) |
| 26 | } |
| 27 | if err := store.Set("beta", json.RawMessage(`{"enabled":true}`)); err != nil { |
| 28 | t.Fatalf("Set beta: %v", err) |
| 29 | } |
| 30 | if err := store.Save(); err != nil { |
| 31 | t.Fatalf("Save: %v", err) |
| 32 | } |
| 33 | |
| 34 | reloaded, err := LoadSessionExtensions(sessionPath) |
| 35 | if err != nil { |
| 36 | t.Fatalf("reload: %v", err) |
| 37 | } |
| 38 | alpha, ok := reloaded.Get("alpha") |
| 39 | if !ok || string(alpha) != `{"count":3,"notes":["a","b"]}` { |
| 40 | t.Fatalf("alpha blob = %q (ok=%v)", alpha, ok) |
| 41 | } |
| 42 | beta, ok := reloaded.Get("beta") |
| 43 | if !ok || string(beta) != `{"enabled":true}` { |
| 44 | t.Fatalf("beta blob = %q (ok=%v)", beta, ok) |
| 45 | } |
| 46 | if got := reloaded.Plugins(); len(got) != 2 || got[0] != "alpha" || got[1] != "beta" { |
| 47 | t.Fatalf("Plugins() = %v", got) |
| 48 | } |
| 49 | |
| 50 | // The on-disk shape is the versioned contract. |
| 51 | raw, err := os.ReadFile(SessionExtensionsPath(sessionPath)) |
| 52 | if err != nil { |
| 53 | t.Fatalf("read store file: %v", err) |
| 54 | } |
| 55 | var file struct { |
| 56 | Version int `json:"version"` |
| 57 | } |
| 58 | if err := json.Unmarshal(raw, &file); err != nil || file.Version != SessionExtensionsVersion { |
| 59 | t.Fatalf("store file version = %d, err = %v", file.Version, err) |
| 60 | } |
| 61 | |
| 62 | // Delete survives a save/reload cycle. |
| 63 | reloaded.Delete("alpha") |
| 64 | if err := reloaded.Save(); err != nil { |
| 65 | t.Fatalf("Save after delete: %v", err) |
| 66 | } |
| 67 | again, err := LoadSessionExtensions(sessionPath) |
| 68 | if err != nil { |
| 69 | t.Fatalf("reload after delete: %v", err) |
| 70 | } |
| 71 | if _, ok := again.Get("alpha"); ok { |
| 72 | t.Fatal("deleted blob survived save/reload") |
| 73 | } |
| 74 | } |
| 75 | |
| 76 | func TestSessionExtensionsBlobCap(t *testing.T) { |
| 77 | store, err := LoadSessionExtensions(filepath.Join(t.TempDir(), "s.jsonl")) |
| 78 | if err != nil { |
| 79 | t.Fatalf("LoadSessionExtensions: %v", err) |
| 80 | } |
| 81 | // Exactly at the cap: a JSON string sized to MaxPluginStateBytes. |
| 82 | atCap := []byte(`"` + strings.Repeat("a", MaxPluginStateBytes-2) + `"`) |
| 83 | if err := store.Set("alpha", atCap); err != nil { |
| 84 | t.Fatalf("Set at the cap: %v", err) |
| 85 | } |
| 86 | overCap := []byte(`"` + strings.Repeat("a", MaxPluginStateBytes-1) + `"`) |
| 87 | err = store.Set("alpha", overCap) |
| 88 | if err == nil { |
| 89 | t.Fatal("Set beyond the cap succeeded") |
| 90 | } |
| 91 | if !errors.Is(err, ErrPluginStateTooLarge) { |
| 92 | t.Fatalf("error = %v, want ErrPluginStateTooLarge", err) |
| 93 | } |
| 94 | // The failed write must not have clobbered the previous blob. |
| 95 | got, ok := store.Get("alpha") |
| 96 | if !ok || len(got) != MaxPluginStateBytes { |
| 97 | t.Fatalf("staged blob after rejected write: %d bytes (ok=%v)", len(got), ok) |
| 98 | } |
| 99 | // Invalid JSON is rejected too. |
| 100 | if err := store.Set("beta", json.RawMessage(`{not json`)); err == nil { |
| 101 | t.Fatal("Set accepted invalid JSON") |
| 102 | } |
| 103 | if err := store.Set("", json.RawMessage(`{}`)); err == nil { |
| 104 | t.Fatal("Set accepted an empty plugin ID") |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | func TestSessionExtensionsCorruptFileTolerated(t *testing.T) { |
| 109 | dir := t.TempDir() |
| 110 | sessionPath := filepath.Join(dir, "session.jsonl") |
| 111 | storePath := SessionExtensionsPath(sessionPath) |
| 112 | if err := os.WriteFile(storePath, []byte("{corrupt json!!!"), 0o644); err != nil { |
| 113 | t.Fatalf("write corrupt store: %v", err) |
| 114 | } |
| 115 | store, err := LoadSessionExtensions(sessionPath) |
| 116 | if err != nil { |
| 117 | t.Fatalf("corrupt store must not fail the load: %v", err) |
| 118 | } |
| 119 | if len(store.Plugins()) != 0 { |
| 120 | t.Fatalf("corrupt store produced plugins %v", store.Plugins()) |
| 121 | } |
| 122 | // Saving over the corrupt file repairs it. |
| 123 | if err := store.Set("alpha", json.RawMessage(`{"ok":true}`)); err != nil { |
| 124 | t.Fatalf("Set: %v", err) |
| 125 | } |
| 126 | if err := store.Save(); err != nil { |
| 127 | t.Fatalf("Save: %v", err) |
| 128 | } |
| 129 | reloaded, err := LoadSessionExtensions(sessionPath) |
| 130 | if err != nil { |
| 131 | t.Fatalf("reload: %v", err) |
| 132 | } |
| 133 | if _, ok := reloaded.Get("alpha"); !ok { |
| 134 | t.Fatal("repaired store lost the blob") |
| 135 | } |
| 136 | } |
| 137 | |
| 138 | // TestSessionExtensionsNeverTouchesSessionJSONL pins the byte-stability |
| 139 | // contract: the session file itself is never read or written by the store. |
| 140 | func TestSessionExtensionsNeverTouchesSessionJSONL(t *testing.T) { |
| 141 | dir := t.TempDir() |
| 142 | sessionPath := filepath.Join(dir, "session.jsonl") |
| 143 | sessionBytes := []byte("{\"role\":\"system\"}\n{\"role\":\"user\"}\n") |
| 144 | if err := os.WriteFile(sessionPath, sessionBytes, 0o644); err != nil { |
| 145 | t.Fatalf("write session: %v", err) |
| 146 | } |
| 147 | |
| 148 | store, err := LoadSessionExtensions(sessionPath) |
| 149 | if err != nil { |
| 150 | t.Fatalf("LoadSessionExtensions: %v", err) |
| 151 | } |
| 152 | if err := store.Set("alpha", json.RawMessage(`{"state":1}`)); err != nil { |
| 153 | t.Fatalf("Set: %v", err) |
| 154 | } |
| 155 | if err := store.Save(); err != nil { |
| 156 | t.Fatalf("Save: %v", err) |
| 157 | } |
| 158 | |
| 159 | after, err := os.ReadFile(sessionPath) |
| 160 | if err != nil { |
| 161 | t.Fatalf("read session: %v", err) |
| 162 | } |
| 163 | if !bytes.Equal(after, sessionBytes) { |
| 164 | t.Fatal("session JSONL bytes changed") |
| 165 | } |
| 166 | if _, err := os.Stat(SessionExtensionsPath(sessionPath)); err != nil { |
| 167 | t.Fatalf("extensions file missing: %v", err) |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | func TestSessionExtensionsEmptySessionPath(t *testing.T) { |
| 172 | store, err := LoadSessionExtensions("") |
| 173 | if err != nil { |
| 174 | t.Fatalf("LoadSessionExtensions: %v", err) |
| 175 | } |
| 176 | if err := store.Save(); err == nil { |
| 177 | t.Fatal("Save without a path succeeded") |
| 178 | } |
| 179 | } |
| 180 |