345 lines
10 KiB
TypeScript
345 lines
10 KiB
TypeScript
import { expect, test } from "vitest";
|
|
|
|
import { ErrorConflict } from "$lib/shared/util/error";
|
|
|
|
import {
|
|
getCategoryNEntries,
|
|
getEntries,
|
|
getEntry,
|
|
getEntryNExecutions,
|
|
getEntryNVersions,
|
|
getEntryVersions,
|
|
getNTodo,
|
|
getPatientNEntries,
|
|
newEntry,
|
|
newEntryExecution,
|
|
newEntryVersion,
|
|
} from "$lib/server/query";
|
|
|
|
const TEST_VERSION = {
|
|
category_id: 1,
|
|
text: "10ml Blut abnehmen",
|
|
date: "2024-01-01",
|
|
priority: false,
|
|
};
|
|
|
|
async function insertTestEntries() {
|
|
// Create some entries
|
|
const eId1 = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const eId2 = await newEntry(1, {
|
|
patient_id: 2,
|
|
version: {
|
|
text: "Carrot cake jelly-o bonbon toffee chocolate.",
|
|
date: "2024-01-05",
|
|
priority: false,
|
|
category_id: null,
|
|
},
|
|
});
|
|
const eId3 = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: {
|
|
text: "Cheesecake danish donut oat cake caramels.",
|
|
date: "2024-01-06",
|
|
priority: false,
|
|
category_id: null,
|
|
},
|
|
});
|
|
|
|
// Update an entry
|
|
await newEntryVersion(2, eId1, {
|
|
category_id: 3,
|
|
text: `${TEST_VERSION.text}\n\n> Hello World`,
|
|
date: "2024-01-01",
|
|
priority: true,
|
|
});
|
|
|
|
// Execute entries
|
|
await newEntryExecution(1, eId2, { text: "Some execution txt", done: true });
|
|
await newEntryExecution(2, eId3, { text: "More execution txt", done: true });
|
|
|
|
return { eId1, eId2, eId3 };
|
|
}
|
|
|
|
test("create entry", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
expect(eId).gt(0);
|
|
|
|
const entry = await getEntry(eId);
|
|
expect(entry.patient.id).toBe(1);
|
|
expect(entry.execution).toBeNull();
|
|
expect(entry.current_version.id).gt(0);
|
|
expect(entry.current_version.category?.id).toBe(TEST_VERSION.category_id);
|
|
expect(entry.current_version.category?.name).toBe("Laborabnahme");
|
|
expect(entry.current_version.text).toBe(TEST_VERSION.text);
|
|
expect(entry.current_version.date).toStrictEqual(TEST_VERSION.date);
|
|
expect(entry.current_version.priority).toBe(TEST_VERSION.priority);
|
|
|
|
const nVersions = await getEntryNVersions(eId);
|
|
expect(nVersions).toBe(1);
|
|
const nExecutions = await getEntryNExecutions(eId);
|
|
expect(nExecutions).toBe(0);
|
|
});
|
|
|
|
test("create entry version", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const text = "10ml Blut abnehmen\n\nPS: Nadel nicht vergessen";
|
|
const date = "2024-01-02";
|
|
|
|
const nvId = await newEntryVersion(1, eId, {
|
|
date,
|
|
text,
|
|
category_id: 2,
|
|
priority: true,
|
|
});
|
|
|
|
const entry = await getEntry(eId);
|
|
const expectedVersion = {
|
|
id: nvId,
|
|
author: { id: 1 },
|
|
date,
|
|
text,
|
|
category: { id: 2 },
|
|
priority: true,
|
|
};
|
|
expect(entry.current_version).toMatchObject(expectedVersion);
|
|
|
|
const history = await getEntryVersions(eId);
|
|
expect(history).length(2);
|
|
expect(history[0]).toMatchObject(expectedVersion);
|
|
expect(history[1].text).toBe(TEST_VERSION.text);
|
|
expect(history[0].created_at).greaterThan(history[1].created_at);
|
|
|
|
const nVersions = await getEntryNVersions(eId);
|
|
expect(nVersions).toBe(2);
|
|
});
|
|
|
|
test("create entry version (partial)", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const oldEntry = await getEntry(eId);
|
|
const text = "10ml Blut abnehmen\n\nPS: Nadel nicht vergessen";
|
|
|
|
await newEntryVersion(2, eId, { text }, oldEntry.current_version.id);
|
|
|
|
const entry = await getEntry(eId);
|
|
expect(entry.current_version).toMatchObject({
|
|
author: { id: 2 },
|
|
date: oldEntry.current_version.date,
|
|
text,
|
|
category: oldEntry.current_version.category,
|
|
priority: oldEntry.current_version.priority,
|
|
});
|
|
});
|
|
|
|
test("create entry version (wrong old vid)", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const entry = await getEntry(eId);
|
|
|
|
await expect(async () => {
|
|
await newEntryVersion(
|
|
1,
|
|
eId,
|
|
{ text: "Hello World" },
|
|
entry.current_version.id + 1,
|
|
);
|
|
}).rejects.toThrowError(new ErrorConflict("old version id does not match"));
|
|
});
|
|
|
|
test("create entry execution", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const text = "Blutabnahme erledigt.";
|
|
|
|
const xId = await newEntryExecution(1, eId, { text, done: true }, null);
|
|
|
|
const entry = await getEntry(eId);
|
|
expect(entry.execution?.id).toBe(xId);
|
|
expect(entry.execution?.author.id).toBe(1);
|
|
expect(entry.execution?.text).toBe(text);
|
|
|
|
const nExecutions = await getEntryNExecutions(eId);
|
|
expect(nExecutions).toBe(1);
|
|
});
|
|
|
|
test("create entry execution (update)", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
|
|
const x1 = await newEntryExecution(1, eId, { text: "x1", done: true }, null);
|
|
const x2 = await newEntryExecution(2, eId, { text: "x2", done: true }, x1);
|
|
|
|
const entry = await getEntry(eId);
|
|
expect(entry.execution?.id).toBe(x2);
|
|
expect(entry.execution?.text).toBe("x2");
|
|
expect(entry.execution?.author.id).toBe(2);
|
|
|
|
const nExecutions = await getEntryNExecutions(eId);
|
|
expect(nExecutions).toBe(2);
|
|
});
|
|
|
|
test("create entry execution (wrong old xid)", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
const x1 = await newEntryExecution(1, eId, { text: "x1", done: true }, null);
|
|
|
|
await expect(async () => newEntryExecution(1, eId, { text: "x2", done: true }, x1 + 1)).rejects.toThrowError(new ErrorConflict("old execution id does not match"));
|
|
});
|
|
|
|
test("get entries", async () => {
|
|
const { eId1, eId2, eId3 } = await insertTestEntries();
|
|
const entries = await getEntries({}, {});
|
|
expect(entries.items).length(3);
|
|
expect(entries.total).toBe(3);
|
|
|
|
// Pagination
|
|
|
|
const entriesLim2 = await getEntries({}, { limit: 2, offset: 0 });
|
|
expect(entriesLim2.items).length(2);
|
|
expect(entriesLim2.total).toBe(3);
|
|
|
|
const entriesLim2Offset = await getEntries({}, { limit: 2, offset: 2 });
|
|
expect(entriesLim2Offset.items).length(1);
|
|
expect(entriesLim2Offset.offset).toBe(2);
|
|
expect(entriesLim2Offset.total).toBe(3);
|
|
|
|
// Filter by category
|
|
const entriesCategory = await getEntries({ category: 3 }, {});
|
|
const entriesCategory2 = await getEntries({ category: [3] }, {});
|
|
expect(entriesCategory.items).length(1);
|
|
expect(entriesCategory.total).toBe(1);
|
|
expect(entriesCategory.items[0].id).toBe(eId1);
|
|
expect(entriesCategory2).toStrictEqual(entriesCategory);
|
|
|
|
// Filter by author
|
|
const entriesAuthor = await getEntries({ author: 2 }, {});
|
|
expect(entriesAuthor.items).length(1);
|
|
expect(entriesAuthor.total).toBe(1);
|
|
expect(entriesAuthor.items[0].id).toBe(eId1);
|
|
|
|
// Filter by executor
|
|
const entriesExecutor = await getEntries({ executor: 1 }, {});
|
|
expect(entriesExecutor.items).length(1);
|
|
expect(entriesExecutor.total).toBe(1);
|
|
expect(entriesExecutor.items[0].id).toBe(eId2);
|
|
|
|
// Filter by patient
|
|
const entriesPatient = await getEntries({ patient: 1 }, {});
|
|
expect(entriesPatient.items).length(2);
|
|
expect(entriesPatient.total).toBe(2);
|
|
expect(entriesPatient.items[0].id).toBe(eId1);
|
|
expect(entriesPatient.items[1].id).toBe(eId3);
|
|
|
|
// Filter by room
|
|
const entriesRoom = await getEntries({ room: 1 }, {});
|
|
expect(entriesRoom).toStrictEqual(entriesPatient);
|
|
|
|
// Filter done
|
|
const entriesDone = await getEntries({ done: true }, {});
|
|
expect(entriesDone.items).length(2);
|
|
expect(entriesDone.total).toBe(2);
|
|
expect(entriesDone.items[0].id).toBe(eId2);
|
|
expect(entriesDone.items[1].id).toBe(eId3);
|
|
|
|
// Filter not done
|
|
const entriesNotDone = await getEntries({ done: false }, {});
|
|
expect(entriesNotDone.items).length(1);
|
|
expect(entriesNotDone.total).toBe(1);
|
|
expect(entriesNotDone.items[0].id).toBe(eId1);
|
|
|
|
// Filter by priority
|
|
const entriesPrio = await getEntries({ priority: true }, {});
|
|
expect(entriesPrio.items).length(1);
|
|
expect(entriesPrio.total).toBe(1);
|
|
expect(entriesPrio.items[0].id).toBe(eId1);
|
|
|
|
// Filter by date range
|
|
const entriesDate = await getEntries({ date: "2024-01-05" });
|
|
expect(entriesDate.items).length(1);
|
|
expect(entriesDate.total).toBe(1);
|
|
expect(entriesDate.items[0].id).toBe(eId2);
|
|
|
|
const entriesDateRange = await getEntries({ date: "2024-01-05..2024-01-06" });
|
|
expect(entriesDateRange.items).length(2);
|
|
expect(entriesDateRange.total).toBe(2);
|
|
expect(entriesDateRange.items[0].id).toBe(eId2);
|
|
expect(entriesDateRange.items[1].id).toBe(eId3);
|
|
|
|
// Search
|
|
const entriesSearch = await getEntries({ search: "Blu" }, {});
|
|
expect(entriesSearch.items).length(1);
|
|
expect(entriesSearch.total).toBe(1);
|
|
expect(entriesSearch.items[0].id).toBe(eId1);
|
|
|
|
// NTodo
|
|
const n = await getNTodo(new Date("2024-01-05"));
|
|
expect(n).toBe(1);
|
|
|
|
// Sort by ID
|
|
const entriesSortedId = await getEntries({}, {}, ["id"]);
|
|
const entriesSortedIdDsc = await getEntries({}, {}, ["id:dsc"]);
|
|
expect(entriesSortedId.total).toBe(3);
|
|
expect(entriesSortedIdDsc.total).toBe(3);
|
|
for (let i = 0; i < 3; i++) {
|
|
expect(entriesSortedId.items[i]).toStrictEqual(
|
|
entriesSortedIdDsc.items[entriesSortedIdDsc.items.length - i - 1],
|
|
);
|
|
}
|
|
|
|
// Sort by patient and ID
|
|
const entriesSortedPatientId = await getEntries({}, {}, ["patient", "id"]);
|
|
expect(entriesSortedPatientId.items.length).toBe(3);
|
|
expect(entriesSortedPatientId.items[0].id).toBe(eId1);
|
|
expect(entriesSortedPatientId.items[1].id).toBe(eId3);
|
|
expect(entriesSortedPatientId.items[2].id).toBe(eId2);
|
|
|
|
const entriesSortedPatientIdDsc = await getEntries({}, {}, ["patient:dsc", "id"]);
|
|
expect(entriesSortedPatientIdDsc.items.length).toBe(3);
|
|
expect(entriesSortedPatientIdDsc.items[0].id).toBe(eId2);
|
|
expect(entriesSortedPatientIdDsc.items[1].id).toBe(eId1);
|
|
expect(entriesSortedPatientIdDsc.items[2].id).toBe(eId3);
|
|
});
|
|
|
|
test("get patient n entries", async () => {
|
|
await insertTestEntries();
|
|
expect(await getPatientNEntries(1)).toBe(2);
|
|
});
|
|
|
|
test("get category n entries", async () => {
|
|
await insertTestEntries();
|
|
expect(await getCategoryNEntries(3)).toBe(1);
|
|
});
|
|
|
|
test("todo execution", async () => {
|
|
const eId = await newEntry(1, {
|
|
patient_id: 1,
|
|
version: TEST_VERSION,
|
|
});
|
|
|
|
const n1 = await newEntryExecution(1, eId, { text: "note1", done: false }, null);
|
|
|
|
const entry = await getEntry(eId);
|
|
expect(entry.execution?.id).toBe(n1);
|
|
expect(entry.execution?.text).toBe("note1");
|
|
expect(entry.execution?.author.id).toBe(1);
|
|
expect(entry.execution?.done).toBe(false);
|
|
});
|