aljaz/turso
1
0
Fork 0
mirror of https://github.com/aljazceru/turso.git synced 2025-12-25 03:54:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

cleanup

Browse Source 
remove happy-dom
try to fix some issues with tests
add wasm-pack as devDependency
update versions
This commit is contained in:
Elijah Morgan
2025-01-06 18:47:08 -05:00
parent d51ca2150c
commit ad9d372e9c
6 changed files with 887 additions and 2112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2733
bindings/wasm/package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

13
bindings/wasm/package.json
View File

@@ -24,12 +24,13 @@
"test:ui": "vitest --ui"
},
"devDependencies": {
"@playwright/test": "^1.40.0",
"@vitest/ui": "^1.0.0",
"happy-dom": "^12.0.0",
"playwright": "^1.40.0",
"vite": "^5.0.0",
"@playwright/test": "^1.49.1",
"@vitest/ui": "^2.1.8",
"happy-dom": "^16.3.0",
"playwright": "^1.49.1",
"vite": "^6.0.7",
"vite-plugin-wasm": "^3.4.1",
"vitest": "^1.0.0"
"vitest": "^2.1.8",
"wasm-pack": "^0.13.1"
}
}

2
bindings/wasm/scripts/build
View File

@@ -8,5 +8,5 @@ if [ "$TARGET" = "web" ]; then
FEATURE="web"
fi
wasm-pack build --no-pack --target $TARGET --no-default-features --features $FEATURE
npx wasm-pack build --no-pack --target $TARGET --no-default-features --features $FEATURE
cp package.json pkg/package.json

1
bindings/wasm/test/limbo.test.js
View File

@@ -1,6 +1,7 @@
import { expect, test } from "vitest";
test("basic database operations", async () => {
await globalThis.beforeEachPromise;
const page = globalThis.__page__;
await page.goto("http://localhost:5173/limbo-test.html");

241
bindings/wasm/test/opfs.test.js
View File

@@ -1,144 +1,131 @@
import { expect, test } from "vitest";
import { beforeEach, describe, expect, test } from "vitest";
test("basic read/write functionality", async () => {
const page = globalThis.__page__;
await page.goto("http://localhost:5173/index.html");
page.on("console", (msg) => console.log(msg.text()));
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("test.txt", {});
const writeData = new Uint8Array([1, 2, 3, 4]);
const bytesWritten = await vfs.pwrite(fd, writeData, 0);
const readData = new Uint8Array(4);
const bytesRead = await vfs.pread(fd, readData, 0);
await vfs.close(fd);
return { fd, bytesWritten, bytesRead, readData: Array.from(readData) };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
describe.sequential("OPFS Tests", () => {
beforeEach(async () => {
await globalThis.beforeEachPromise;
const page = globalThis.__page__;
await page.goto("http://localhost:5173/index.html");
await page.waitForFunction(() => window.VFSInterface !== undefined);
});
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.fd).toBe(1);
expect(result.bytesWritten).toBe(4);
expect(result.bytesRead).toBe(4);
expect(result.readData).toEqual([1, 2, 3, 4]);
});
test("basic read/write functionality", async () => {
const page = globalThis.__page__;
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("test.txt", {});
const writeData = new Uint8Array([1, 2, 3, 4]);
const bytesWritten = await vfs.pwrite(fd, writeData, 0);
const readData = new Uint8Array(4);
const bytesRead = await vfs.pread(fd, readData, 0);
await vfs.close(fd);
return { fd, bytesWritten, bytesRead, readData: Array.from(readData) };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
});
test("larger data read/write", async () => {
const page = globalThis.__page__;
await page.goto("http://localhost:5173/index.html");
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("large.txt", {});
const writeData = new Uint8Array(1024).map((_, i) => i % 256);
const bytesWritten = await vfs.pwrite(fd, writeData, 0);
const readData = new Uint8Array(1024);
const bytesRead = await vfs.pread(fd, readData, 0);
await vfs.close(fd);
return { bytesWritten, bytesRead, readData: Array.from(readData) };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.fd).toBe(1);
expect(result.bytesWritten).toBe(4);
expect(result.bytesRead).toBe(4);
expect(result.readData).toEqual([1, 2, 3, 4]);
});
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.bytesWritten).toBe(1024);
expect(result.bytesRead).toBe(1024);
expect(result.readData).toEqual(
Array.from({ length: 1024 }, (_, i) => i % 256),
);
});
test("larger data read/write", async () => {
const page = globalThis.__page__;
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("large.txt", {});
const writeData = new Uint8Array(1024).map((_, i) => i % 256);
const bytesWritten = await vfs.pwrite(fd, writeData, 0);
const readData = new Uint8Array(1024);
const bytesRead = await vfs.pread(fd, readData, 0);
await vfs.close(fd);
return { bytesWritten, bytesRead, readData: Array.from(readData) };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
});
test("partial reads and writes", async () => {
const page = globalThis.__page__;
await page.goto("http://localhost:5173/index.html");
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("partial.txt", {});
// Write data in chunks
const writeData1 = new Uint8Array([1, 2, 3, 4]);
const writeData2 = new Uint8Array([5, 6, 7, 8]);
await vfs.pwrite(fd, writeData1, 0);
await vfs.pwrite(fd, writeData2, 4);
// Read partial chunks
const readData1 = new Uint8Array(2);
const readData2 = new Uint8Array(4);
const readData3 = new Uint8Array(2);
await vfs.pread(fd, readData1, 0); // Should read [1,2]
await vfs.pread(fd, readData2, 2); // Should read [3,4,5,6]
await vfs.pread(fd, readData3, 6); // Should read [7,8]
await vfs.close(fd);
return {
readData1: Array.from(readData1),
readData2: Array.from(readData2),
readData3: Array.from(readData3),
};
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.bytesWritten).toBe(1024);
expect(result.bytesRead).toBe(1024);
expect(result.readData).toEqual(
Array.from({ length: 1024 }, (_, i) => i % 256),
);
});
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.readData1).toEqual([1, 2]);
expect(result.readData2).toEqual([3, 4, 5, 6]);
expect(result.readData3).toEqual([7, 8]);
});
test("partial reads and writes", async () => {
const page = globalThis.__page__;
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("partial.txt", {});
test("file size operations", async () => {
const page = globalThis.__page__;
await page.goto("http://localhost:5173/index.html");
const writeData1 = new Uint8Array([1, 2, 3, 4]);
const writeData2 = new Uint8Array([5, 6, 7, 8]);
await vfs.pwrite(fd, writeData1, 0);
await vfs.pwrite(fd, writeData2, 4);
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
const readData1 = new Uint8Array(2);
const readData2 = new Uint8Array(4);
const readData3 = new Uint8Array(2);
try {
fd = await vfs.open("size.txt", {});
await vfs.pread(fd, readData1, 0);
await vfs.pread(fd, readData2, 2);
await vfs.pread(fd, readData3, 6);
// First write
const writeData1 = new Uint8Array([1, 2, 3, 4]);
await vfs.pwrite(fd, writeData1, 0);
const size1 = await vfs.size(fd);
await vfs.close(fd);
return {
readData1: Array.from(readData1),
readData2: Array.from(readData2),
readData3: Array.from(readData3),
};
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
});
// Second write with new array
const writeData2 = new Uint8Array([5, 6, 7, 8]);
await vfs.pwrite(fd, writeData2, 4);
const size2 = await vfs.size(fd);
await vfs.close(fd);
return { size1, size2 };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(result.readData1).toEqual([1, 2]);
expect(result.readData2).toEqual([3, 4, 5, 6]);
expect(result.readData3).toEqual([7, 8]);
});
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(Number(result.size1)).toBe(4);
expect(Number(result.size2)).toBe(8);
test("file size operations", async () => {
const page = globalThis.__page__;
const result = await page.evaluate(async () => {
const vfs = new window.VFSInterface("/src/opfs-worker.js");
let fd;
try {
fd = await vfs.open("size.txt", {});
const writeData1 = new Uint8Array([1, 2, 3, 4]);
await vfs.pwrite(fd, writeData1, 0);
const size1 = await vfs.size(fd);
const writeData2 = new Uint8Array([5, 6, 7, 8]);
await vfs.pwrite(fd, writeData2, 4);
const size2 = await vfs.size(fd);
await vfs.close(fd);
return { size1, size2 };
} catch (error) {
if (fd !== undefined) await vfs.close(fd);
return { error: error.message };
}
});
if (result.error) throw new Error(`Test failed: ${result.error}`);
expect(Number(result.size1)).toBe(4);
expect(Number(result.size2)).toBe(8);
});
});

9
bindings/wasm/test/setup.js
View File

@@ -20,9 +20,12 @@ beforeAll(async () => {
});
beforeEach(async () => {
context = await browser.newContext();
page = await context.newPage();
globalThis.__page__ = page;
globalThis.beforeEachPromise = (async () => {
context = await browser.newContext();
page = await context.newPage();
globalThis.__page__ = page;
})();
await globalThis.beforeEachPromise;
});
afterEach(async () => {