dmitry.galkin/chatbot-template
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert "Upgrade linter and formatter to Ultracite" (#1226)

Browse source
This commit is contained in:
josh 2025-09-21 12:03:29 +01:00 • committed by GitHub
parent 0e320b391d
commit 1aff7d9868
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
177 changed files with 8334 additions and 6943 deletions
Download patch file Download diff file Expand all files Collapse all files

158
tests/routes/chat.test.ts
View file

@ -1,19 +1,19 @@
import { getMessageByErrorCode } from "@/lib/errors";
import { generateUUID } from "@/lib/utils";
import { expect, test } from "../fixtures";
import { TEST_PROMPTS } from "../prompts/routes";
import { generateUUID } from '@/lib/utils';
import { expect, test } from '../fixtures';
import { TEST_PROMPTS } from '../prompts/routes';
import { getMessageByErrorCode } from '@/lib/errors';
const chatIdsCreatedByAda: string[] = [];
const chatIdsCreatedByAda: Array<string> = [];
// Helper function to normalize stream data for comparison
function normalizeStreamData(lines: string[]): string[] {
return lines.map((line) => {
if (line.startsWith("data: ")) {
if (line.startsWith('data: ')) {
try {
const data = JSON.parse(line.slice(6)); // Remove 'data: ' prefix
if (data.id) {
// Replace dynamic id with a static one for comparison
return `data: ${JSON.stringify({ ...data, id: "STATIC_ID" })}`;
return `data: ${JSON.stringify({ ...data, id: 'STATIC_ID' })}`;
}
return line;
} catch {
@ -25,40 +25,40 @@ function normalizeStreamData(lines: string[]): string[] {
}
test.describe
.serial("/api/chat", () => {
test("Ada cannot invoke a chat generation with empty request body", async ({
.serial('/api/chat', () => {
test('Ada cannot invoke a chat generation with empty request body', async ({
adaContext,
}) => {
const response = await adaContext.request.post("/api/chat", {
const response = await adaContext.request.post('/api/chat', {
data: JSON.stringify({}),
});
expect(response.status()).toBe(400);
const { code, message } = await response.json();
expect(code).toEqual("bad_request:api");
expect(message).toEqual(getMessageByErrorCode("bad_request:api"));
expect(code).toEqual('bad_request:api');
expect(message).toEqual(getMessageByErrorCode('bad_request:api'));
});
test("Ada can invoke chat generation", async ({ adaContext }) => {
test('Ada can invoke chat generation', async ({ adaContext }) => {
const chatId = generateUUID();
const response = await adaContext.request.post("/api/chat", {
const response = await adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: TEST_PROMPTS.SKY.MESSAGE,
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
expect(response.status()).toBe(200);
const text = await response.text();
const lines = text.split("\n");
const lines = text.split('\n');
const [_, ...rest] = lines;
const actualNormalized = normalizeStreamData(rest.filter(Boolean));
const expectedNormalized = normalizeStreamData(
TEST_PROMPTS.SKY.OUTPUT_STREAM
TEST_PROMPTS.SKY.OUTPUT_STREAM,
);
expect(actualNormalized).toEqual(expectedNormalized);
@ -71,39 +71,39 @@ test.describe
}) => {
const [chatId] = chatIdsCreatedByAda;
const response = await babbageContext.request.post("/api/chat", {
const response = await babbageContext.request.post('/api/chat', {
data: {
id: chatId,
message: TEST_PROMPTS.GRASS.MESSAGE,
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
expect(response.status()).toBe(403);
const { code, message } = await response.json();
expect(code).toEqual("forbidden:chat");
expect(message).toEqual(getMessageByErrorCode("forbidden:chat"));
expect(code).toEqual('forbidden:chat');
expect(message).toEqual(getMessageByErrorCode('forbidden:chat'));
});
test("Babbage cannot delete Ada's chat", async ({ babbageContext }) => {
const [chatId] = chatIdsCreatedByAda;
const response = await babbageContext.request.delete(
`/api/chat?id=${chatId}`
`/api/chat?id=${chatId}`,
);
expect(response.status()).toBe(403);
const { code, message } = await response.json();
expect(code).toEqual("forbidden:chat");
expect(message).toEqual(getMessageByErrorCode("forbidden:chat"));
expect(code).toEqual('forbidden:chat');
expect(message).toEqual(getMessageByErrorCode('forbidden:chat'));
});
test("Ada can delete her own chat", async ({ adaContext }) => {
test('Ada can delete her own chat', async ({ adaContext }) => {
const [chatId] = chatIdsCreatedByAda;
const response = await adaContext.request.delete(
`/api/chat?id=${chatId}`
`/api/chat?id=${chatId}`,
);
expect(response.status()).toBe(200);
@ -111,42 +111,42 @@ test.describe
expect(deletedChat).toMatchObject({ id: chatId });
});
test("Ada cannot resume stream of chat that does not exist", async ({
test('Ada cannot resume stream of chat that does not exist', async ({
adaContext,
}) => {
const response = await adaContext.request.get(
`/api/chat/${generateUUID()}/stream`
`/api/chat/${generateUUID()}/stream`,
);
expect(response.status()).toBe(404);
});
test("Ada can resume chat generation", async ({ adaContext }) => {
test('Ada can resume chat generation', async ({ adaContext }) => {
const chatId = generateUUID();
const firstRequest = adaContext.request.post("/api/chat", {
const firstRequest = adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: {
id: generateUUID(),
role: "user",
content: "Help me write an essay about Silcon Valley",
role: 'user',
content: 'Help me write an essay about Silcon Valley',
parts: [
{
type: "text",
text: "Help me write an essay about Silicon Valley",
type: 'text',
text: 'Help me write an essay about Silicon Valley',
},
],
createdAt: new Date().toISOString(),
},
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
await new Promise((resolve) => setTimeout(resolve, 1000));
const secondRequest = adaContext.request.get(
`/api/chat/${chatId}/stream`
`/api/chat/${chatId}/stream`,
);
const [firstResponse, secondResponse] = await Promise.all([
@ -168,37 +168,37 @@ test.describe
]);
expect(firstResponseBody.toString()).toEqual(
secondResponseBody.toString()
secondResponseBody.toString(),
);
});
test("Ada can resume chat generation that has ended during request", async ({
test('Ada can resume chat generation that has ended during request', async ({
adaContext,
}) => {
const chatId = generateUUID();
const firstRequest = await adaContext.request.post("/api/chat", {
const firstRequest = await adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: {
id: generateUUID(),
role: "user",
content: "Help me write an essay about Silcon Valley",
role: 'user',
content: 'Help me write an essay about Silcon Valley',
parts: [
{
type: "text",
text: "Help me write an essay about Silicon Valley",
type: 'text',
text: 'Help me write an essay about Silicon Valley',
},
],
createdAt: new Date().toISOString(),
},
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
const secondRequest = adaContext.request.get(
`/api/chat/${chatId}/stream`
`/api/chat/${chatId}/stream`,
);
const [firstResponse, secondResponse] = await Promise.all([
@ -219,31 +219,31 @@ test.describe
secondResponse.text(),
]);
expect(secondResponseContent).toContain("appendMessage");
expect(secondResponseContent).toContain('appendMessage');
});
test("Ada cannot resume chat generation that has ended", async ({
test('Ada cannot resume chat generation that has ended', async ({
adaContext,
}) => {
const chatId = generateUUID();
const firstResponse = await adaContext.request.post("/api/chat", {
const firstResponse = await adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: {
id: generateUUID(),
role: "user",
content: "Help me write an essay about Silcon Valley",
role: 'user',
content: 'Help me write an essay about Silcon Valley',
parts: [
{
type: "text",
text: "Help me write an essay about Silicon Valley",
type: 'text',
text: 'Help me write an essay about Silicon Valley',
},
],
createdAt: new Date().toISOString(),
},
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
@ -252,48 +252,48 @@ test.describe
await firstResponse.text();
await new Promise((resolve) => setTimeout(resolve, 15 * 1000));
await new Promise((resolve) => setTimeout(resolve, 15_000));
await new Promise((resolve) => setTimeout(resolve, 15000));
const secondResponse = await adaContext.request.get(
`/api/chat/${chatId}/stream`
`/api/chat/${chatId}/stream`,
);
const secondStatusCode = secondResponse.status();
expect(secondStatusCode).toBe(200);
const secondResponseContent = await secondResponse.text();
expect(secondResponseContent).toEqual("");
expect(secondResponseContent).toEqual('');
});
test("Babbage cannot resume a private chat generation that belongs to Ada", async ({
test('Babbage cannot resume a private chat generation that belongs to Ada', async ({
adaContext,
babbageContext,
}) => {
const chatId = generateUUID();
const firstRequest = adaContext.request.post("/api/chat", {
const firstRequest = adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: {
id: generateUUID(),
role: "user",
content: "Help me write an essay about Silcon Valley",
role: 'user',
content: 'Help me write an essay about Silcon Valley',
parts: [
{
type: "text",
text: "Help me write an essay about Silicon Valley",
type: 'text',
text: 'Help me write an essay about Silicon Valley',
},
],
createdAt: new Date().toISOString(),
},
selectedChatModel: "chat-model",
selectedVisibilityType: "private",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'private',
},
});
await new Promise((resolve) => setTimeout(resolve, 1000));
const secondRequest = babbageContext.request.get(
`/api/chat/${chatId}/stream`
`/api/chat/${chatId}/stream`,
);
const [firstResponse, secondResponse] = await Promise.all([
@ -310,37 +310,37 @@ test.describe
expect(secondStatusCode).toBe(403);
});
test("Babbage can resume a public chat generation that belongs to Ada", async ({
test('Babbage can resume a public chat generation that belongs to Ada', async ({
adaContext,
babbageContext,
}) => {
test.fixme();
const chatId = generateUUID();
const firstRequest = adaContext.request.post("/api/chat", {
const firstRequest = adaContext.request.post('/api/chat', {
data: {
id: chatId,
message: {
id: generateUUID(),
role: "user",
content: "Help me write an essay about Silicon Valley",
role: 'user',
content: 'Help me write an essay about Silicon Valley',
parts: [
{
type: "text",
text: "Help me write an essay about Silicon Valley",
type: 'text',
text: 'Help me write an essay about Silicon Valley',
},
],
createdAt: new Date().toISOString(),
},
selectedChatModel: "chat-model",
selectedVisibilityType: "public",
selectedChatModel: 'chat-model',
selectedVisibilityType: 'public',
},
});
await new Promise((resolve) => setTimeout(resolve, 10 * 1000));
const secondRequest = babbageContext.request.get(
`/api/chat/${chatId}/stream`
`/api/chat/${chatId}/stream`,
);
const [firstResponse, secondResponse] = await Promise.all([

78
tests/routes/document.test.ts
View file

@ -1,52 +1,52 @@
import type { Document } from "@/lib/db/schema";
import { getMessageByErrorCode } from "@/lib/errors";
import { generateUUID } from "@/lib/utils";
import { expect, test } from "../fixtures";
import type { Document } from '@/lib/db/schema';
import { generateUUID } from '@/lib/utils';
import { expect, test } from '../fixtures';
import { getMessageByErrorCode } from '@/lib/errors';
const documentsCreatedByAda: Document[] = [];
const documentsCreatedByAda: Array<Document> = [];
test.describe
.serial("/api/document", () => {
test("Ada cannot retrieve a document without specifying an id", async ({
.serial('/api/document', () => {
test('Ada cannot retrieve a document without specifying an id', async ({
adaContext,
}) => {
const response = await adaContext.request.get("/api/document");
const response = await adaContext.request.get('/api/document');
expect(response.status()).toBe(400);
const { code, message } = await response.json();
expect(code).toEqual("bad_request:api");
expect(code).toEqual('bad_request:api');
expect(message).toEqual(getMessageByErrorCode(code));
});
test("Ada cannot retrieve a document that does not exist", async ({
test('Ada cannot retrieve a document that does not exist', async ({
adaContext,
}) => {
const documentId = generateUUID();
const response = await adaContext.request.get(
`/api/document?id=${documentId}`
`/api/document?id=${documentId}`,
);
expect(response.status()).toBe(404);
const { code, message } = await response.json();
expect(code).toEqual("not_found:document");
expect(code).toEqual('not_found:document');
expect(message).toEqual(getMessageByErrorCode(code));
});
test("Ada can create a document", async ({ adaContext }) => {
test('Ada can create a document', async ({ adaContext }) => {
const documentId = generateUUID();
const draftDocument = {
title: "Ada's Document",
kind: "text",
content: "Created by Ada",
kind: 'text',
content: 'Created by Ada',
};
const response = await adaContext.request.post(
`/api/document?id=${documentId}`,
{
data: draftDocument,
}
},
);
expect(response.status()).toBe(200);
@ -56,11 +56,11 @@ test.describe
documentsCreatedByAda.push(createdDocument);
});
test("Ada can retrieve a created document", async ({ adaContext }) => {
test('Ada can retrieve a created document', async ({ adaContext }) => {
const [document] = documentsCreatedByAda;
const response = await adaContext.request.get(
`/api/document?id=${document.id}`
`/api/document?id=${document.id}`,
);
expect(response.status()).toBe(200);
@ -71,22 +71,22 @@ test.describe
expect(retrievedDocument).toMatchObject(document);
});
test("Ada can save a new version of the document", async ({
test('Ada can save a new version of the document', async ({
adaContext,
}) => {
const [firstDocument] = documentsCreatedByAda;
const draftDocument = {
title: "Ada's Document",
kind: "text",
content: "Updated by Ada",
kind: 'text',
content: 'Updated by Ada',
};
const response = await adaContext.request.post(
`/api/document?id=${firstDocument.id}`,
{
data: draftDocument,
}
},
);
expect(response.status()).toBe(200);
@ -96,13 +96,13 @@ test.describe
documentsCreatedByAda.push(createdDocument);
});
test("Ada can retrieve all versions of her documents", async ({
test('Ada can retrieve all versions of her documents', async ({
adaContext,
}) => {
const [firstDocument, secondDocument] = documentsCreatedByAda;
const response = await adaContext.request.get(
`/api/document?id=${firstDocument.id}`
`/api/document?id=${firstDocument.id}`,
);
expect(response.status()).toBe(200);
@ -115,39 +115,39 @@ test.describe
expect(secondRetrievedDocument).toMatchObject(secondDocument);
});
test("Ada cannot delete a document without specifying an id", async ({
test('Ada cannot delete a document without specifying an id', async ({
adaContext,
}) => {
const response = await adaContext.request.delete("/api/document");
const response = await adaContext.request.delete(`/api/document`);
expect(response.status()).toBe(400);
const { code, message } = await response.json();
expect(code).toEqual("bad_request:api");
expect(code).toEqual('bad_request:api');
expect(message).toEqual(getMessageByErrorCode(code));
});
test("Ada cannot delete a document without specifying a timestamp", async ({
test('Ada cannot delete a document without specifying a timestamp', async ({
adaContext,
}) => {
const [firstDocument] = documentsCreatedByAda;
const response = await adaContext.request.delete(
`/api/document?id=${firstDocument.id}`
`/api/document?id=${firstDocument.id}`,
);
expect(response.status()).toBe(400);
const { code, message } = await response.json();
expect(code).toEqual("bad_request:api");
expect(code).toEqual('bad_request:api');
expect(message).toEqual(getMessageByErrorCode(code));
});
test("Ada can delete a document by specifying id and timestamp", async ({
test('Ada can delete a document by specifying id and timestamp', async ({
adaContext,
}) => {
const [firstDocument, secondDocument] = documentsCreatedByAda;
const response = await adaContext.request.delete(
`/api/document?id=${firstDocument.id}&timestamp=${firstDocument.createdAt}`
`/api/document?id=${firstDocument.id}&timestamp=${firstDocument.createdAt}`,
);
expect(response.status()).toBe(200);
@ -158,13 +158,13 @@ test.describe
expect(deletedDocument).toMatchObject(secondDocument);
});
test("Ada can retrieve documents without deleted versions", async ({
test('Ada can retrieve documents without deleted versions', async ({
adaContext,
}) => {
const [firstDocument] = documentsCreatedByAda;
const response = await adaContext.request.get(
`/api/document?id=${firstDocument.id}`
`/api/document?id=${firstDocument.id}`,
);
expect(response.status()).toBe(200);
@ -180,20 +180,20 @@ test.describe
const draftDocument = {
title: "Babbage's Document",
kind: "text",
content: "Created by Babbage",
kind: 'text',
content: 'Created by Babbage',
};
const response = await babbageContext.request.post(
`/api/document?id=${firstDocument.id}`,
{
data: draftDocument,
}
},
);
expect(response.status()).toBe(403);
const { code, message } = await response.json();
expect(code).toEqual("forbidden:document");
expect(code).toEqual('forbidden:document');
expect(message).toEqual(getMessageByErrorCode(code));
});
@ -201,7 +201,7 @@ test.describe
const [firstDocument] = documentsCreatedByAda;
const response = await adaContext.request.get(
`/api/document?id=${firstDocument.id}`
`/api/document?id=${firstDocument.id}`,
);
expect(response.status()).toBe(200);