@peerbit/indexer-tests 1.1.1 → 1.1.2-4d7d8ba

package/dist/src/tests.d.ts

@@ -1,3 +1,6 @@
 import { type Indices } from "@peerbit/indexer-interface";
-export declare const tests: (createIndicies: (directory?: string) => Indices | Promise<Indices>, type: "transient" | "persist", shapingSupported: boolean) => Mocha.Suite;
+export declare const tests: (createIndicies: (directory?: string) => Indices | Promise<Indices>, type: "transient" | "persist", properties: {
+    shapingSupported: boolean;
+    u64SumSupported: boolean;
+}) => Mocha.Suite;
 //# sourceMappingURL=tests.d.ts.map

package/dist/src/tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/tests.ts"],"names":[],"mappings":"AAUA,OAAO,EAQN,KAAK,OAAO,EAiBZ,MAAM,4BAA4B,CAAC;AA0GpC,eAAO,MAAM,KAAK,mBACD,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAC5D,WAAW,GAAG,SAAS,oBACX,OAAO,gBAmtGzB,CAAC"}
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/tests.ts"],"names":[],"mappings":"AAUA,OAAO,EAQN,KAAK,OAAO,EAiBZ,MAAM,4BAA4B,CAAC;AA0GpC,eAAO,MAAM,KAAK,mBACD,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAC5D,WAAW,GAAG,SAAS,cACjB;IACX,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;CACzB,gBA41GD,CAAC"}

package/dist/src/tests.js

@@ -136,7 +136,7 @@ const assertIteratorIsDone = async (iterator) => {
     }
     expect(iterator.done()).to.be.true;
 };
-export const tests = (createIndicies, type = "transient", shapingSupported) => {
+export const tests = (createIndicies, type = "transient", properties) => {
     return describe("index", () => {
         let store;
         let indices;
@@ -435,34 +435,33 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     await testIndex(store, doc);
                 });
             });
-            describe("bigint", () => {
+            /* TMP renable with sqlite support u64
+             describe("bigint", () => {
                 class DocumentBigintId {
-                    id;
-                    value;
-                    constructor(properties) {
+                    @field({ type: "u64" })
+                    id: bigint;
+
+                    @field({ type: "u64" })
+                    value: bigint;
+
+                    constructor(properties: { id: bigint; value: bigint }) {
                         this.id = properties.id;
                         this.value = properties.value;
                     }
                 }
-                __decorate([
-                    field({ type: "u64" }),
-                    __metadata("design:type", BigInt)
-                ], DocumentBigintId.prototype, "id", void 0);
-                __decorate([
-                    field({ type: "string" }),
-                    __metadata("design:type", String)
-                ], DocumentBigintId.prototype, "value", void 0);
+
                 it("index as bigint", async () => {
                     const { store } = await setup({ schema: DocumentBigintId });
+
                     // make the id less than 2^53, but greater than u32 max
-                    const id = BigInt(2 ** 53 - 1);
+                    const id = BigInt(2 ** 63 - 1);
                     const doc = new DocumentBigintId({
                         id,
-                        value: "Hello world",
+                        value: id,
                     });
                     await testIndex(store, doc);
                 });
-            });
+            }); */
             describe("by decorator", () => {
                 class DocumentWithDecoratedId {
                     xyz;
@@ -770,7 +769,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         });
                     });
                 });
-                +it("bool", async () => {
+                it("bool", async () => {
                     await setupDefault();
                     const responses = await search(store, {
                         query: [
@@ -2095,7 +2094,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                         const results = await search(store, { query: [] }, { shape: { id: true } });
                         expect(results).to.have.length(4);
                         for (const result of results) {
-                            if (shapingSupported) {
+                            if (properties.shapingSupported) {
                                 expect(Object.keys(result.value)).to.have.length(1);
                                 expect(result.value["id"]).to.exist;
                             }
@@ -2114,7 +2113,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             if (arr.length > 0) {
                                 for (const element of arr) {
                                     expect(element.number).to.exist;
-                                    if (shapingSupported) {
+                                    if (properties.shapingSupported) {
                                         expect(Object.keys(element)).to.have.length(1);
                                     }
                                 }
@@ -2179,7 +2178,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
@@ -2215,7 +2214,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect({ ...shapedResults[0].value.nested }).to.deep.equal({
                                 bool: false,
                             });
@@ -2316,7 +2315,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
@@ -2352,7 +2351,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect({ ...shapedResults[0].value.nested }).to.deep.equal({
                                 bool: false,
                             });
@@ -2419,7 +2418,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal("2");
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect(shapedResults[0].value["nested"]).to.be.undefined;
                         }
                         else {
@@ -2447,7 +2446,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                             .all();
                         expect(shapedResults).to.have.length(1);
                         expect(shapedResults[0].value.id).to.equal(d2.id);
-                        if (shapingSupported) {
+                        if (properties.shapingSupported) {
                             expect({ ...shapedResults[0].value.nested[0] }).to.deep.equal({
                                 bool: false,
                             });
@@ -2481,9 +2480,9 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
             });
         });
         describe("sort", () => {
-            const put = async (id) => {
+            const put = async (id, stringId) => {
                 const doc = new Document({
-                    id: String(id),
+                    id: stringId ?? String(id),
                     name: String(id),
                     number: BigInt(id),
                     tags: [],
@@ -2547,7 +2546,7 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                 await put(0);
                 await put(1);
                 await put(2);
-                {
+                const f1 = async () => {
                     const iterator = store.iterate({
                         query: [],
                         sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
@@ -2556,8 +2555,8 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     const next = await iterator.next(3);
                     expect(next.map((x) => x.value.name)).to.deep.equal(["0", "1", "2"]);
                     await assertIteratorIsDone(iterator);
-                }
-                {
+                };
+                const f2 = async () => {
                     const iterator = store.iterate({
                         query: [],
                         sort: [new Sort({ direction: SortDirection.DESC, key: "name" })],
@@ -2566,13 +2565,100 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
                     const next = await iterator.next(3);
                     expect(next.map((x) => x.value.name)).to.deep.equal(["2", "1", "0"]);
                     await assertIteratorIsDone(iterator);
-                }
+                };
+                await f1();
+                await f2();
             });
+            it("sorts by order", async () => {
+                await put(0);
+                await put(1);
+                await put(2);
+                const f1 = async () => {
+                    const iterator = store.iterate({
+                        query: [],
+                        sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+                    });
+                    expect(iterator.done()).to.be.undefined;
+                    const next = await iterator.next(3);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["0", "1", "2"]);
+                    await assertIteratorIsDone(iterator);
+                };
+                const f2 = async () => {
+                    const iterator = store.iterate({
+                        query: [],
+                        sort: [new Sort({ direction: SortDirection.DESC, key: "name" })],
+                    });
+                    expect(iterator.done()).to.be.undefined;
+                    const next = await iterator.next(3);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["2", "1", "0"]);
+                    await assertIteratorIsDone(iterator);
+                };
+                const f3 = async () => {
+                    const iterator = store.iterate({
+                        query: [],
+                        sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+                    });
+                    expect(iterator.done()).to.be.undefined;
+                    let next = await iterator.next(2);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["0", "1"]);
+                    next = await iterator.next(1);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["2"]);
+                    await assertIteratorIsDone(iterator);
+                };
+                const f4 = async () => {
+                    const iterator = store.iterate({
+                        query: [],
+                        sort: [new Sort({ direction: SortDirection.DESC, key: "name" })],
+                    });
+                    expect(iterator.done()).to.be.undefined;
+                    let next = await iterator.next(2);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["2", "1"]);
+                    next = await iterator.next(1);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["0"]);
+                    await assertIteratorIsDone(iterator);
+                };
+                const f5 = async () => {
+                    const iterator = store.iterate({
+                        query: [],
+                        sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+                    });
+                    expect(iterator.done()).to.be.undefined;
+                    let next = await iterator.next(1);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["0"]);
+                    next = await iterator.next(1);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["1"]);
+                    next = await iterator.next(1);
+                    expect(next.map((x) => x.value.name)).to.deep.equal(["2"]);
+                    await assertIteratorIsDone(iterator);
+                };
+                await f1();
+                await f2();
+                await f3();
+                await f4();
+                await f5();
+            });
+            /* it("no sort is stable", async () => {
+                // TODO this test is actually not a good predictor of stability
+
+                const insertCount = 500;
+                for (let i = 0; i < insertCount; i++) {
+                    await put(i, uuid());
+                }
+
+                const resolvedValues: Set<number> = new Set()
+                const batchSize = 123;
+                const iterator = store.iterate();
+                while (!iterator.done()) {
+                    const next = await iterator.next(batchSize);
+                    next.map((x) => resolvedValues.add(Number(x.value.number)));
+                }
+                expect(resolvedValues.size).to.equal(insertCount);
+            }); */
             it("strings", async () => {
                 await put(0);
                 await put(1);
                 await put(2);
-                const iterator = await store.iterate({
+                const iterator = store.iterate({
                     query: [],
                     sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
                 });
@@ -2881,23 +2967,63 @@ export const tests = (createIndicies, type = "transient", shapingSupported) => {
             // TODO session timeouts?
         });
         describe("sum", () => {
+            class SummableDocument {
+                id;
+                value;
+                constructor(opts) {
+                    this.id = opts.id;
+                    this.value = opts.value;
+                }
+            }
+            __decorate([
+                field({ type: "string" }),
+                __metadata("design:type", String)
+            ], SummableDocument.prototype, "id", void 0);
+            __decorate([
+                field({ type: option("u32") }),
+                __metadata("design:type", Number)
+            ], SummableDocument.prototype, "value", void 0);
             it("it returns sum", async () => {
-                await setupDefault();
-                const sum = await store.sum({ key: "number" });
+                await setup({ schema: SummableDocument });
+                await store.put(new SummableDocument({
+                    id: "1",
+                    value: 1,
+                }));
+                await store.put(new SummableDocument({
+                    id: "2",
+                    value: 2,
+                }));
+                const sum = await store.sum({ key: "value" });
                 typeof sum === "bigint"
-                    ? expect(sum).to.equal(6n)
-                    : expect(sum).to.equal(6);
+                    ? expect(sum).to.equal(3n)
+                    : expect(sum).to.equal(3);
             });
+            if (properties.u64SumSupported) {
+                it("u64", async () => {
+                    await setupDefault();
+                    const sum = await store.sum({ key: "number" });
+                    typeof sum === "bigint"
+                        ? expect(sum).to.equal(6n)
+                        : expect(sum).to.equal(6);
+                });
+            }
             it("it returns sum with query", async () => {
-                await setupDefault();
+                await setup({ schema: SummableDocument });
+                await store.put(new SummableDocument({
+                    id: "1",
+                    value: 1,
+                }));
+                await store.put(new SummableDocument({
+                    id: "2",
+                    value: 2,
+                }));
                 const sum = await store.sum({
-                    key: "number",
+                    key: "value",
                     query: [
-                        new StringMatch({
-                            key: "tags",
-                            value: "world",
-                            method: StringMatchMethod.contains,
-                            caseInsensitive: true,
+                        new IntegerCompare({
+                            key: "value",
+                            compare: Compare.Greater,
+                            value: 1,
                         }),
                     ],
                 });