1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
package storage
import (
"elefant/models"
"fmt"
"log/slog"
"os"
"testing"
"time"
_ "github.com/glebarez/go-sqlite"
"github.com/jmoiron/sqlx"
)
func TestMemories(t *testing.T) {
db, err := sqlx.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("Failed to open SQLite in-memory database: %v", err)
}
defer db.Close()
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS memories (
agent TEXT NOT NULL,
topic TEXT NOT NULL,
mind TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (agent, topic)
);`)
if err != nil {
t.Fatalf("Failed to create chat table: %v", err)
}
provider := ProviderSQL{
db: db,
logger: slog.New(slog.NewJSONHandler(os.Stdout, nil)),
}
// Create a sample memory for testing
sampleMemory := &models.Memory{
Agent: "testAgent",
Topic: "testTopic",
Mind: "testMind",
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
cases := []struct {
memory *models.Memory
}{
{memory: sampleMemory},
}
for i, tc := range cases {
t.Run(fmt.Sprintf("run_%d", i), func(t *testing.T) {
// Recall topics: get no rows
topics, err := provider.RecallTopics(tc.memory.Agent)
if err != nil {
t.Fatalf("Failed to recall topics: %v", err)
}
if len(topics) != 0 {
t.Fatalf("Expected no topics, got: %v", topics)
}
// Memorise
_, err = provider.Memorise(tc.memory)
if err != nil {
t.Fatalf("Failed to memorise: %v", err)
}
// Recall topics: has topics
topics, err = provider.RecallTopics(tc.memory.Agent)
if err != nil {
t.Fatalf("Failed to recall topics: %v", err)
}
if len(topics) == 0 {
t.Fatalf("Expected topics, got none")
}
// Recall
content, err := provider.Recall(tc.memory.Agent, tc.memory.Topic)
if err != nil {
t.Fatalf("Failed to recall: %v", err)
}
if content != tc.memory.Mind {
t.Fatalf("Expected content: %v, got: %v", tc.memory.Mind, content)
}
})
}
}
func TestChatHistory(t *testing.T) {
// Create an in-memory SQLite database
db, err := sqlx.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("Failed to open SQLite in-memory database: %v", err)
}
defer db.Close()
// Create the chat table
_, err = db.Exec(`
CREATE TABLE chats (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
msgs TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);`)
if err != nil {
t.Fatalf("Failed to create chat table: %v", err)
}
// Initialize the ProviderSQL struct
provider := ProviderSQL{db: db}
// List chats (should be empty)
chats, err := provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 0 {
t.Errorf("Expected 0 chats, got %d", len(chats))
}
// Upsert a chat
chat := &models.Chat{
ID: 1,
Name: "Test Chat",
Msgs: "Hello World",
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
updatedChat, err := provider.UpsertChat(chat)
if err != nil {
t.Fatalf("Failed to upsert chat: %v", err)
}
if updatedChat == nil {
t.Errorf("Expected non-nil chat after upsert")
}
// Get chat by ID
fetchedChat, err := provider.GetChatByID(chat.ID)
if err != nil {
t.Fatalf("Failed to get chat by ID: %v", err)
}
if fetchedChat == nil {
t.Errorf("Expected non-nil chat after get")
}
if fetchedChat.Name != chat.Name {
t.Errorf("Expected chat name %s, got %s", chat.Name, fetchedChat.Name)
}
// List chats (should contain the upserted chat)
chats, err = provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 1 {
t.Errorf("Expected 1 chat, got %d", len(chats))
}
// Remove chat
err = provider.RemoveChat(chat.ID)
if err != nil {
t.Fatalf("Failed to remove chat: %v", err)
}
// List chats (should be empty again)
chats, err = provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 0 {
t.Errorf("Expected 0 chats, got %d", len(chats))
}
}
|
