xonecas.io
5875
Os

ollama-space-molt-player / files

ollama-space-molt-player / packages / client / tests / db.test.ts

6.4 KB
1import { afterEach, beforeEach, describe, expect, test } from "bun:test";
2import { GameDatabase, generateInstanceId, instanceExists, listInstances } from "../src/db.ts";
3import type { AccountDetails } from "../src/types.ts";
4
5describe("GameDatabase", () => {
6	let db: GameDatabase;
7	let testInstanceId: string;
8
9	beforeEach(() => {
10		testInstanceId = `test-${Date.now()}`;
11		db = new GameDatabase(testInstanceId);
12	});
13
14	afterEach(() => {
15		db.close();
16
17		const fs = require("node:fs");
18		const dbFile = `memory-${testInstanceId}.sqlite`;
19		if (fs.existsSync(dbFile)) {
20			fs.unlinkSync(dbFile);
21		}
22	});
23
24	describe("Instance Operations", () => {
25		test("should retrieve instance with hint", () => {
26			const instance = db.getInstance();
27			expect(instance.instance_id).toBe(testInstanceId);
28			expect(instance.hint).toBeNull();
29		});
30
31		test("should update hint", () => {
32			db.updateHint("new hint");
33			const instance = db.getInstance();
34			expect(instance.hint).toBe("new hint");
35		});
36
37		test("should track logged_out state", () => {
38			expect(db.isLoggedOut()).toBe(false);
39
40			db.setLoggedOut(true);
41			expect(db.isLoggedOut()).toBe(true);
42
43			db.setLoggedOut(false);
44			expect(db.isLoggedOut()).toBe(false);
45		});
46
47		test("should persist logged_out in instance", () => {
48			db.setLoggedOut(true);
49			const instance = db.getInstance();
50			expect(instance.logged_out).toBe(1);
51		});
52	});
53
54	describe("Username Operations", () => {
55		test("should save and retrieve username", () => {
56			db.saveUsername("TestPlayer", "test-token-123", "Test prompt", "player-uuid", 100);
57
58			const usernames = db.getUsernames();
59			expect(usernames.length).toBe(1);
60			expect(usernames[0].username).toBe("TestPlayer");
61			expect(usernames[0].token).toBe("test-token-123");
62			expect(usernames[0].prompt).toBe("Test prompt");
63			expect(usernames[0].player_id).toBe("player-uuid");
64			expect(usernames[0].last_used_on).toBe(100);
65		});
66
67		test("should return empty array when no usernames exist", () => {
68			const usernames = db.getUsernames();
69			expect(usernames.length).toBe(0);
70		});
71
72		test("should get active username (most recent)", () => {
73			db.saveUsername("Player1", "token1", "prompt1", "id1", 100);
74			db.saveUsername("Player2", "token2", "prompt2", "id2", 200);
75			db.saveUsername("Player3", "token3", "prompt3", "id3", 150);
76
77			const active = db.getActiveUsername();
78			expect(active?.username).toBe("Player2");
79			expect(active?.last_used_on).toBe(200);
80		});
81
82		test("should return null when no active username", () => {
83			const active = db.getActiveUsername();
84			expect(active).toBeNull();
85		});
86
87		test("should update username prompt", () => {
88			db.saveUsername("TestPlayer", "token", "original prompt", "id", 100);
89			db.updateUsernamePrompt("TestPlayer", "updated prompt");
90
91			const usernames = db.getUsernames();
92			expect(usernames[0].prompt).toBe("updated prompt");
93		});
94
95		test("should update username last_used_on", () => {
96			db.saveUsername("TestPlayer", "token", "prompt", "id", 100);
97			db.updateUsernameLastUsed("TestPlayer", 200);
98
99			const active = db.getActiveUsername();
100			expect(active?.last_used_on).toBe(200);
101		});
102
103		test("should return usernames sorted by last_used_on", () => {
104			db.saveUsername("Player1", "token1", "prompt1", "id1", 100);
105			db.saveUsername("Player2", "token2", "prompt2", "id2", 300);
106			db.saveUsername("Player3", "token3", "prompt3", "id3", 200);
107
108			const usernames = db.getUsernames();
109			expect(usernames.length).toBe(3);
110			expect(usernames[0].username).toBe("Player2");
111			expect(usernames[1].username).toBe("Player3");
112			expect(usernames[2].username).toBe("Player1");
113		});
114	});
115
116	describe("Message Operations", () => {
117		test("should save and retrieve messages", () => {
118			db.saveMessage(1, "server", { type: "tick", payload: { tick: 1 } });
119			db.saveMessage(2, "client", { type: "get_status" });
120
121			const messages = db.getMessages();
122
123			expect(messages.length).toBe(2);
124			expect(messages[0].tick).toBe(2);
125			expect(messages[0].sender).toBe("client");
126			expect(messages[1].tick).toBe(1);
127			expect(messages[1].sender).toBe("server");
128		});
129
130		test("should parse JSON data correctly", () => {
131			const data = { type: "tick", payload: { tick: 42 } };
132			db.saveMessage(42, "server", data);
133
134			const messages = db.getMessages();
135			const retrieved = JSON.parse(messages[0].data);
136
137			expect(retrieved).toEqual(data);
138		});
139
140		test("should get message count", () => {
141			expect(db.getMessageCount()).toBe(0);
142
143			db.saveMessage(1, "server", { type: "tick" });
144			expect(db.getMessageCount()).toBe(1);
145
146			db.saveMessage(2, "server", { type: "tick" });
147			expect(db.getMessageCount()).toBe(2);
148		});
149
150		test("should limit retrieved messages", () => {
151			for (let i = 0; i < 100; i++) {
152				db.saveMessage(i, "server", { type: "tick" });
153			}
154
155			const messages = db.getMessages(10);
156			expect(messages.length).toBe(10);
157		});
158
159		test("should clear all messages", () => {
160			db.saveMessage(1, "server", { type: "tick" });
161			db.saveMessage(2, "server", { type: "tick" });
162
163			db.clearMessages();
164			expect(db.getMessageCount()).toBe(0);
165		});
166	});
167
168	describe("Utility", () => {
169		test("should return instance ID", () => {
170			expect(db.getInstanceId()).toBe(testInstanceId);
171		});
172
173		test("should close database", () => {
174			expect(() => db.close()).not.toThrow();
175		});
176	});
177});
178
179describe("Instance Management", () => {
180	test("should generate 4-character instance ID", () => {
181		const id = generateInstanceId();
182		expect(id.length).toBe(4);
183		expect(/^[a-z0-9]{4}$/.test(id)).toBe(true);
184	});
185
186	test("should generate unique IDs", () => {
187		const ids = new Set();
188		for (let i = 0; i < 100; i++) {
189			ids.add(generateInstanceId());
190		}
191		expect(ids.size).toBeGreaterThan(90);
192	});
193
194	test("should check if instance exists", async () => {
195		const id = `test-exists-${Date.now()}`;
196		expect(await instanceExists(id)).toBe(false);
197
198		const db = new GameDatabase(id);
199		expect(await instanceExists(id)).toBe(true);
200
201		db.close();
202		const fs = require("node:fs");
203		fs.unlinkSync(`memory-${id}.sqlite`);
204	});
205
206	test("should list existing instances", () => {
207		const id1 = `test-list-${Date.now()}-1`;
208		const id2 = `test-list-${Date.now()}-2`;
209
210		const db1 = new GameDatabase(id1);
211		const db2 = new GameDatabase(id2);
212
213		const instances = listInstances();
214		expect(instances).toContain(id1);
215		expect(instances).toContain(id2);
216
217		db1.close();
218		db2.close();
219
220		const fs = require("node:fs");
221		fs.unlinkSync(`memory-${id1}.sqlite`);
222		fs.unlinkSync(`memory-${id2}.sqlite`);
223	});
224});