@peerbit/indexer-tests 1.1.3 → 1.1.4-03739af

package/src/tests.ts

@@ -7,7 +7,7 @@ import {
 	variant,
 	vec,
 } from "@dao-xyz/borsh";
-import { randomBytes } from "@peerbit/crypto";
+import { randomBytes, sha256Base64Sync } from "@peerbit/crypto";
 import {
 	And,
 	BoolQuery,
@@ -20,7 +20,6 @@ import {
 	IntegerCompare,
 	IsNull,
 	type IterateOptions,
-	Nested,
 	Not,
 	Or,
 	Query,
@@ -289,7 +288,7 @@ export const tests = (
 
 		afterEach(async () => {
 			defaultDocs = [];
-			await indices?.stop?.();
+			await indices?.drop?.();
 		});
 
 		describe("indexBy", () => {
@@ -492,8 +491,7 @@ export const tests = (
 				});
 			});
 
-			/* TMP renable with sqlite support u64
-			 describe("bigint", () => {
+			describe("bigint", () => {
 				class DocumentBigintId {
 					@field({ type: "u64" })
 					id: bigint;
@@ -518,7 +516,7 @@ export const tests = (
 					});
 					await testIndex(store, doc);
 				});
-			}); */
+			});
 
 			describe("by decorator", () => {
 				class DocumentWithDecoratedId {
@@ -913,38 +911,263 @@ export const tests = (
 							@field({ type: vec(Document) })
 							documents: Document[];
 
-							constructor(properties?: { documents: Document[] }) {
+							constructor(properties?: {
+								id?: Uint8Array;
+								documents: Document[];
+							}) {
 								this.id = randomBytes(32);
 								this.documents = properties?.documents || [];
 							}
 						}
 
-						it("can search", async () => {
-							const out = await setup({ schema: DocumentsVec });
-							store = out.store;
+						class DocumentWithProperty {
+							@field({ type: "string" })
+							property: string;
 
-							const d1 = new DocumentsVec({
-								documents: [
-									new Document({ id: uuid(), number: 123n, tags: [] }),
-								],
-							});
-							await store.put(d1);
-							await store.put(
-								new DocumentsVec({
+							constructor(property: string) {
+								this.property = property;
+							}
+						}
+
+						class DocumentsVecWithPropertyDocument {
+							@field({ type: Uint8Array })
+							id: Uint8Array;
+
+							@field({ type: "string" })
+							property: string;
+
+							@field({ type: vec(DocumentWithProperty) })
+							documents: DocumentWithProperty[];
+
+							constructor(properties: {
+								id?: Uint8Array;
+								property: string;
+								documents: DocumentWithProperty[];
+							}) {
+								this.id = randomBytes(32);
+								this.property = properties.property;
+								this.documents = properties?.documents || [];
+							}
+						}
+
+						describe("search", () => {
+							let d1: DocumentsVec;
+							let d2: DocumentsVec;
+							let d3: DocumentsVec;
+
+							beforeEach(async () => {
+								const out = await setup({ schema: DocumentsVec });
+								store = out.store;
+
+								d1 = new DocumentsVec({
+									id: new Uint8Array([0]),
+									documents: [
+										new Document({ id: uuid(), number: 123n, tags: [] }),
+									],
+								});
+								await store.put(d1);
+
+								d2 = new DocumentsVec({
+									id: new Uint8Array([1]),
 									documents: [
 										new Document({ id: uuid(), number: 124n, tags: [] }),
 									],
-								}),
-							);
+								});
 
-							const results = await search(store, {
-								query: new IntegerCompare({
-									key: ["documents", "number"],
-									compare: Compare.Equal,
-									value: d1.documents[0]!.number,
-								}),
+								await store.put(d2);
+
+								d3 = new DocumentsVec({
+									id: new Uint8Array([2]),
+									documents: [
+										new Document({ id: uuid(), number: 122n, tags: [] }),
+										new Document({ id: uuid(), number: 125n, tags: [] }),
+									],
+								});
+
+								await store.put(d3);
+							});
+
+							it("match", async () => {
+								// equality
+								const results = await search(store, {
+									query: new IntegerCompare({
+										key: ["documents", "number"],
+										compare: Compare.Equal,
+										value: d1.documents[0]!.number,
+									}),
+								});
+								expect(results.map((x) => x.value.id)).to.deep.equal([d1.id]);
+							});
+
+							describe("logical", () => {
+								it("and", async () => {
+									// can not be equal to two different things at once
+									let results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 123n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 124n,
+												}),
+											]),
+										],
+									});
+									expect(results).to.have.length(0);
+
+									// can not be between two different things at once
+									results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Less,
+													value: 1000n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Greater,
+													value: 1000n,
+												}),
+											]),
+										],
+									});
+									expect(results).to.have.length(0);
+
+									// between one value matches
+									results = await search(store, {
+										query: [
+											new Or([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Less,
+													value: 124n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.GreaterOrEqual,
+													value: 125n,
+												}),
+											]),
+										],
+									});
+
+									// because each query is applied separately
+									expect(
+										results.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([d1.id, d3.id].map(sha256Base64Sync));
+
+									results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Less,
+													value: 124n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.GreaterOrEqual,
+													value: 123n,
+												}),
+											]),
+										],
+									});
+
+									expect(results.map((x) => x.value.id)).to.deep.eq([d1.id]);
+								});
+
+								it("or", async () => {
+									const results3 = await search(store, {
+										query: [
+											new Or([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 123n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 124n,
+												}),
+											]),
+										],
+									});
+
+									expect(
+										results3.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d2.id),
+									]);
+								});
+
+								it("many or", async () => {
+									let conditions: IntegerCompare[] = [];
+									for (let i = 0; i < 100; i++) {
+										conditions.push(
+											new IntegerCompare({
+												key: ["documents", "number"],
+												compare: Compare.Equal,
+												value: 123n,
+											}),
+										);
+										conditions.push(
+											new IntegerCompare({
+												key: ["documents", "number"],
+												compare: Compare.Equal,
+												value: 124n,
+											}),
+										);
+									}
+									const results3 = await search(store, {
+										query: [new Or(conditions)],
+									});
+
+									expect(
+										results3.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d2.id),
+									]);
+								});
+
+								it("or arr, or field", async () => {
+									const results3 = await search(store, {
+										query: [
+											new Or([
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 123n,
+												}),
+												new IntegerCompare({
+													key: ["documents", "number"],
+													compare: Compare.Equal,
+													value: 124n,
+												}),
+												new ByteMatchQuery({
+													key: "id",
+													value: new Uint8Array([1]),
+												}),
+											]),
+										],
+									});
+
+									expect(
+										results3.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d2.id),
+									]);
+								});
 							});
-							expect(results.map((x) => x.value.id)).to.deep.equal([d1.id]);
 						});
 
 						it("update array", async () => {
@@ -1049,6 +1272,384 @@ export const tests = (
 								).length,
 							).to.equal(0);
 						});
+
+						it("can use re-use same property name", async () => {
+							const out = await setup({
+								schema: DocumentsVecWithPropertyDocument,
+							});
+							store = out.store;
+
+							const d1 = new DocumentsVecWithPropertyDocument({
+								property: "property 1",
+								documents: [new DocumentWithProperty("nested property 1")],
+							});
+
+							const d2 = new DocumentsVecWithPropertyDocument({
+								property: "property 2",
+								documents: [new DocumentWithProperty("nested property 2")],
+							});
+
+							await store.put(d1);
+							await store.put(d2);
+
+							const results = await search(store, {
+								query: new StringMatch({
+									key: "property",
+									value: "property 1",
+									caseInsensitive: false,
+								}),
+							});
+
+							expect(results).to.have.length(1);
+							expect(results[0].value.property).to.equal("property 1");
+
+							const resultsNested = await search(store, {
+								query: new StringMatch({
+									key: ["documents", "property"],
+									value: "nested property 2",
+									caseInsensitive: false,
+								}),
+							});
+
+							expect(resultsNested).to.have.length(1);
+							expect(resultsNested[0].value.property).to.equal("property 2");
+						});
+					});
+
+					describe("simple value", () => {
+						class ArrayDocument {
+							@field({ type: Uint8Array })
+							id: Uint8Array;
+
+							@field({ type: vec("u32") })
+							array: number[];
+
+							constructor(properties?: { id?: Uint8Array; array: number[] }) {
+								this.id = properties.id || randomBytes(32);
+								this.array = properties?.array || [];
+							}
+						}
+
+						describe("search", () => {
+							let d1: ArrayDocument;
+							let d2: ArrayDocument;
+							let d3: ArrayDocument;
+
+							beforeEach(async () => {
+								const out = await setup({ schema: ArrayDocument });
+								store = out.store;
+
+								d1 = new ArrayDocument({
+									id: new Uint8Array([0]),
+									array: [1],
+								});
+								await store.put(d1);
+
+								d2 = new ArrayDocument({
+									id: new Uint8Array([1]),
+									array: [2],
+								});
+
+								await store.put(d2);
+
+								d3 = new ArrayDocument({
+									id: new Uint8Array([2]),
+									array: [0, 3],
+								});
+
+								await store.put(d3);
+							});
+
+							it("match", async () => {
+								// equality
+								const results = await search(store, {
+									query: new IntegerCompare({
+										key: ["array"],
+										compare: Compare.Equal,
+										value: d1.array[0]!,
+									}),
+								});
+								expect(results.map((x) => x.value.id)).to.deep.equal([d1.id]);
+							});
+
+							describe("logical", () => {
+								it("and", async () => {
+									// can not be equal to two different things at once
+									let results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Equal,
+													value: d1.array[0]!,
+												}),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Equal,
+													value: d2.array[0]!,
+												}),
+											]),
+										],
+									});
+									expect(results).to.have.length(0);
+
+									// can not be between two different things at once
+									results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Less,
+													value: 1000,
+												}),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Greater,
+													value: 1000,
+												}),
+											]),
+										],
+									});
+									expect(results).to.have.length(0);
+
+									// between one value matches
+									results = await search(store, {
+										query: [
+											new Or([
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Less,
+													value: 2,
+												}),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.GreaterOrEqual,
+													value: 3,
+												}),
+											]),
+										],
+									});
+
+									// because each query is applied separately
+									expect(
+										results.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([d1.id, d3.id].map(sha256Base64Sync));
+
+									results = await search(store, {
+										query: [
+											new And([
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Less,
+													value: 2,
+												}),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.GreaterOrEqual,
+													value: 1,
+												}),
+											]),
+										],
+									});
+
+									// using nested path will apply the queries together
+									expect(
+										results.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([d1.id].map(sha256Base64Sync));
+								});
+
+								it("or", async () => {
+									const results3 = await search(store, {
+										query: [
+											new Or([
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Equal,
+													value: d1.array[0]!,
+												}),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.Equal,
+													value: d3.array[0]!,
+												}),
+											]),
+										],
+									});
+
+									expect(
+										results3.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d3.id),
+									]);
+								});
+
+								it("or array, or field", async () => {
+									const results3 = await search(store, {
+										query: [
+											new Or([
+												new And([
+													new IntegerCompare({
+														key: ["array"],
+														compare: Compare.LessOrEqual,
+														value: 0,
+													}),
+													new IntegerCompare({
+														key: ["array"],
+														compare: Compare.LessOrEqual,
+														value: 1,
+													}),
+												]),
+												new ByteMatchQuery({
+													key: "id",
+													value: new Uint8Array([0]),
+												}),
+											]),
+										],
+									});
+
+									expect(
+										results3.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d3.id),
+									]);
+								});
+
+								it("or all", async () => {
+									const results = await search(store, {
+										query: [
+											new Or([
+												new Or([
+													new And([
+														new IntegerCompare({
+															key: ["array"],
+															compare: Compare.GreaterOrEqual,
+															value: 0,
+														}),
+													]),
+													new And([
+														new IntegerCompare({
+															key: ["array"],
+															compare: Compare.GreaterOrEqual,
+															value: 0,
+														}),
+													]),
+												]),
+												new IntegerCompare({
+													key: ["array"],
+													compare: Compare.GreaterOrEqual,
+													value: 0,
+												}),
+											]),
+										],
+									});
+
+									expect(
+										results.map((x) => sha256Base64Sync(x.value.id)),
+									).to.have.members([
+										sha256Base64Sync(d1.id),
+										sha256Base64Sync(d2.id),
+										sha256Base64Sync(d3.id),
+									]);
+								});
+							});
+						});
+
+						it("update array", async () => {
+							const out = await setup({ schema: ArrayDocument });
+							store = out.store;
+
+							const d1 = new ArrayDocument({
+								array: [123],
+							});
+							await store.put(d1);
+
+							d1.array = [124];
+
+							await store.put(d1);
+
+							// should have update results
+							expect(
+								(
+									await search(store, {
+										query: new IntegerCompare({
+											key: ["array"],
+											compare: Compare.Equal,
+											value: 123,
+										}),
+									})
+								).length,
+							).to.equal(0);
+
+							expect(
+								(
+									await search(store, {
+										query: new IntegerCompare({
+											key: ["array"],
+											compare: Compare.Equal,
+											value: 124,
+										}),
+									})
+								).map((x) => x.value.id),
+							).to.deep.equal([d1.id]);
+						});
+
+						it("put delete put", async () => {
+							const { store } = await setup({ schema: ArrayDocument });
+
+							const d1 = new ArrayDocument({
+								array: [123],
+							});
+
+							await store.put(d1);
+							const [deleted] = await store.del({
+								query: {
+									id: d1.id,
+								},
+							});
+
+							expect(deleted.key).to.deep.equal(d1.id);
+
+							expect(
+								(
+									await search(store, {
+										query: new IntegerCompare({
+											key: ["array"],
+											compare: Compare.Equal,
+											value: 123,
+										}),
+									})
+								).length,
+							).to.equal(0);
+
+							d1.array = [124];
+							await store.put(d1);
+
+							expect(
+								(
+									await search(store, {
+										query: new IntegerCompare({
+											key: ["array"],
+											compare: Compare.Equal,
+											value: 124,
+										}),
+									})
+								).map((x) => x.value.id),
+							).to.deep.equal([d1.id]);
+
+							expect(
+								(
+									await search(store, {
+										query: new IntegerCompare({
+											key: ["array"],
+											compare: Compare.Equal,
+											value: 123,
+										}),
+									})
+								).length,
+							).to.equal(0);
+						});
 					});
 				});
 
@@ -1134,7 +1735,7 @@ export const tests = (
 								new IntegerCompare({
 									key: "number",
 									compare: Compare.Equal,
-									value: 2n,
+									value: 2,
 								}),
 							],
 						});
@@ -1148,7 +1749,7 @@ export const tests = (
 								new IntegerCompare({
 									key: "number",
 									compare: Compare.Greater,
-									value: 2n,
+									value: 2,
 								}),
 							],
 						});
@@ -1162,7 +1763,7 @@ export const tests = (
 								new IntegerCompare({
 									key: "number",
 									compare: Compare.GreaterOrEqual,
-									value: 2n,
+									value: 2,
 								}),
 							],
 						});
@@ -1180,7 +1781,7 @@ export const tests = (
 								new IntegerCompare({
 									key: "number",
 									compare: Compare.Less,
-									value: 2n,
+									value: 2,
 								}),
 							],
 						});
@@ -1205,6 +1806,20 @@ export const tests = (
 						expect(response[0].value.number).to.be.oneOf([1n, 1]);
 						expect(response[1].value.number).to.be.oneOf([2n, 2]);
 					});
+
+					it("bigint as compare value", async () => {
+						const response = await search(store, {
+							query: [
+								new IntegerCompare({
+									key: "number",
+									compare: Compare.Less,
+									value: 2n,
+								}),
+							],
+						});
+						expect(response).to.have.length(1);
+						expect(response[0].value.number).to.be.oneOf([1n, 1]);
+					});
 				});
 
 				describe("bigint", () => {
@@ -1315,6 +1930,19 @@ export const tests = (
 						expect(response[0].value.bigint).to.equal(first);
 						expect(response[1].value.bigint).to.equal(second);
 					});
+
+					it("number as compare value", async () => {
+						const response = await search(store, {
+							query: [
+								new IntegerCompare({
+									key: "bigint",
+									compare: Compare.Greater,
+									value: 1,
+								}),
+							],
+						});
+						expect(response).to.have.length(3);
+					});
 				});
 
 				describe("nested", () => {
@@ -1350,6 +1978,31 @@ export const tests = (
 							await setup({ schema: DocumentWithNesting });
 						});
 
+						it("all", async () => {
+							await store.put(
+								new DocumentWithNesting({
+									id: "1",
+									nested: new Nested({ number: 1n, bool: false }),
+								}),
+							);
+
+							await store.put(
+								new DocumentWithNesting({
+									id: "2",
+									nested: undefined,
+								}),
+							);
+
+							const all = await search(store, {});
+							expect(all).to.have.length(2);
+							expect(all.map((x) => x.id.primitive)).to.have.members([
+								"1",
+								"2",
+							]);
+							expect(all[0].value.nested).to.be.instanceOf(Nested);
+							expect(all[1].value.nested).to.be.undefined;
+						});
+
 						it("number", async () => {
 							await store.put(
 								new DocumentWithNesting({
@@ -2098,21 +2751,16 @@ export const tests = (
 									);
 
 									const response = await search(store, {
-										query: [
-											new Nested({
-												path: "array",
-												query: new And([
-													new StringMatch({
-														key: "a",
-														value: "hello",
-													}),
-													new StringMatch({
-														key: "b",
-														value: "world",
-													}),
-												]),
+										query: new And([
+											new StringMatch({
+												key: ["array", "a"],
+												value: "hello",
 											}),
-										],
+											new StringMatch({
+												key: ["array", "b"],
+												value: "world",
+											}),
+										]),
 									});
 
 									expect(response).to.have.length(1);
@@ -2132,24 +2780,40 @@ export const tests = (
 											}),
 										],
 									});
+									const doc2 = new NestedMultipleFieldsArrayDocument({
+										id: "2",
+										array: [
+											new NestedMultipleFieldsDocument({
+												a: "hello",
+												b: "värld",
+											}),
+											new NestedMultipleFieldsDocument({
+												a: "hej",
+												b: "world",
+											}),
+										],
+									});
+
+									const doc3 = new NestedMultipleFieldsArrayDocument({
+										id: "3",
+										array: [
+											new NestedMultipleFieldsDocument({
+												a: "_",
+												b: "_",
+											}),
+											new NestedMultipleFieldsDocument({
+												a: "_",
+												b: "_",
+											}),
+										],
+									});
+
 									await store.put(doc1);
-									await store.put(
-										new NestedMultipleFieldsArrayDocument({
-											id: "2",
-											array: [
-												new NestedMultipleFieldsDocument({
-													a: "hello",
-													b: "värld",
-												}),
-												new NestedMultipleFieldsDocument({
-													a: "hej",
-													b: "world",
-												}),
-											],
-										}),
-									);
+									await store.put(doc2);
+									await store.put(doc3);
 
-									const response = await search(store, {
+									// AND will only yield doc 1 since only doc 1 contains the combination below
+									const responseAnd = await search(store, {
 										query: [
 											new StringMatch({
 												key: ["array", "a"],
@@ -2162,8 +2826,28 @@ export const tests = (
 										],
 									});
 
+									expect(responseAnd).to.have.length(1);
+									checkDocument(responseAnd[0].value, doc1);
+
+									// OR will only yield doc 1 and doc 2 since both will fulfill one of two conditions
+									const response = await search(store, {
+										query: [
+											new Or([
+												new StringMatch({
+													key: ["array", "a"],
+													value: "hello",
+												}),
+												new StringMatch({
+													key: ["array", "b"],
+													value: "world",
+												}),
+											]),
+										],
+									});
 									expect(response).to.have.length(2);
+
 									checkDocument(response[0].value, doc1);
+									checkDocument(response[1].value, doc2);
 								});
 							});
 						});
@@ -2695,11 +3379,14 @@ export const tests = (
 		});
 
 		describe("sort", () => {
-			const put = async (id: number, stringId?: string) => {
+			const put = async (
+				id: number,
+				options?: { name?: string; number?: bigint },
+			) => {
 				const doc = new Document({
-					id: stringId ?? String(id),
-					name: String(id),
-					number: BigInt(id),
+					id: String(id),
+					name: options?.name ?? String(id),
+					number: options?.number ?? BigInt(id),
 					tags: [],
 				});
 				const resp = await store.put(doc);
@@ -2868,12 +3555,12 @@ export const tests = (
 
 			/* 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();
@@ -2899,6 +3586,25 @@ export const tests = (
 				await assertIteratorIsDone(iterator);
 			});
 
+			it("sort by multiple properties", async () => {
+				await put(0, { name: "a", number: 2n });
+				await put(1, { name: "a", number: 1n });
+
+				await put(2, { name: "b", number: 2n });
+				await put(3, { name: "b", number: 1n });
+
+				const iterator = store.iterate({
+					query: [],
+					sort: [
+						new Sort({ direction: SortDirection.DESC, key: "name" }),
+						new Sort({ direction: SortDirection.ASC, key: "number" }),
+					],
+				});
+
+				const out = await iterator.all();
+				expect(out.map((x) => x.value.id)).to.deep.equal(["3", "2", "1", "0"]);
+			});
+
 			describe("nested", () => {
 				it("variants", async () => {
 					const doc1 = new Document({
@@ -3397,6 +4103,8 @@ export const tests = (
 			});
 
 			it("indices", async () => {
+				// TODO make this test more clear and the purpose of each call
+
 				let { directory, indices } = await setupDefault();
 
 				let subindex = await indices.scope("x");
@@ -3419,7 +4127,11 @@ export const tests = (
 
 				await indices.drop();
 
-				await store.start();
+				const out = await setup({ schema: Document }, directory);
+				indices = out.indices;
+				await indices.start();
+
+				store = out.store;
 
 				expect(await store.getSize()).equal(0);
 
@@ -3428,7 +4140,6 @@ export const tests = (
 
 				store = (await setup({ schema: Document }, directory)).store;
 
-				await store.start();
 				expect(await store.getSize()).equal(0);
 			});
 		});