@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/search-entries-tool-test-C4aG0ckM.js

@@ -1,504 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
-import { Br as testRealmURL, Co as SupportedMimeType } from "./runtime-common-BTaLJEw-.js";
-import { T as rri } from "./paths-C9-NYXnM.js";
-import { n as composeSearchEntriesQuery, t as SearchEntriesTool } from "./search-entries-BY1kIB6C.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { D as realmConfigCardJSON, F as setupLocalIndexing, I as setupOnSave, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, Z as withCachedRealmSetup, bt as resetCatalogRealmURL, lt as setupRenderingTest, t as setupMockMatrix, xt as setCatalogRealmURL } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/search-entries-tool-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealm2URL = "http://test-realm/test2/";
-var longReadMe = `# Author card\n\n${"The Author card models a writer with biographical fields. ".repeat(20)}`;
-(0, import_qunit.module)("Integration | tools | search-entries", function(hooks) {
-	setupRenderingTest(hooks);
-	const realmName = "Search Entries Workspace";
-	let loader;
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	setupLocalIndexing(hooks);
-	setupOnSave(hooks);
-	setupRealmCacheTeardown(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, testRealm2URL],
-		autostart: true
-	});
-	function runSearch(input) {
-		return new SearchEntriesTool(getService("tool-service").toolContext).execute(input);
-	}
-	hooks.beforeEach(async function() {
-		loader = getService("loader-service").loader;
-		let cardApi;
-		let string;
-		let spec;
-		cardApi = await loader.import("@cardstack/base/card-api");
-		string = await loader.import("@cardstack/base/string");
-		spec = await loader.import("@cardstack/base/spec");
-		let { field, contains, CardDef } = cardApi;
-		let { default: StringField } = string;
-		let { Spec } = spec;
-		class Author extends CardDef {
-			static displayName = "Author";
-			static {
-				decorateFieldV2(this.prototype, "firstName", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#firstName = (initializeDeferredDecorator(this, "firstName"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "lastName", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#lastName = (initializeDeferredDecorator(this, "lastName"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "bio", [field], function() {
-					return contains(StringField);
-				});
-			}
-			#bio = (initializeDeferredDecorator(this, "bio"), void 0);
-			static {
-				decorateFieldV2(this.prototype, "cardTitle", [field], function() {
-					return contains(StringField, { computeVia: function() {
-						return [this.firstName, this.lastName].filter(Boolean).join(" ");
-					} });
-				});
-			}
-			#cardTitle = (initializeDeferredDecorator(this, "cardTitle"), void 0);
-		}
-		let authorInstances = {};
-		for (let i = 1; i <= 12; i++) authorInstances[`Author/author-${i}.json`] = new Author({
-			firstName: `Author${i}`,
-			lastName: "Example",
-			bio: `Prolific example writer number ${i}.`
-		});
-		for (let i = 1; i <= 5; i++) authorInstances[`Author/capped-${i}.json`] = new Author({
-			firstName: `Capped${i}`,
-			lastName: "Capped",
-			bio: `First-realm capped writer number ${i}.`
-		});
-		await withCachedRealmSetup(async () => {
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				contents: {
-					"author.gts": { Author },
-					...authorInstances,
-					"Author/mark.json": new Author({
-						firstName: "Mark",
-						lastName: "Jackson",
-						bio: "Novelist specializing in xylophone-themed mystery fiction."
-					}),
-					"Spec/author.json": new Spec({
-						cardTitle: "Author",
-						cardDescription: "Spec for the Author card definition",
-						specType: "card",
-						readMe: longReadMe,
-						ref: {
-							module: `${testRealmURL}author`,
-							name: "Author"
-						}
-					}),
-					"notes.md": "# Workspace notes\n\nA plain markdown file fixture.",
-					"realm.json": realmConfigCardJSON({
-						name: realmName,
-						iconURL: "https://boxel-images.boxel.ai/icons/Letter-o.png"
-					})
-				}
-			});
-			let secondRealmAuthors = {};
-			for (let i = 1; i <= 5; i++) secondRealmAuthors[`Author/other-${i}.json`] = { data: {
-				type: "card",
-				attributes: {
-					firstName: `Other${i}`,
-					lastName: "Capped",
-					bio: `Second-realm capped writer number ${i}.`
-				},
-				meta: { adoptsFrom: {
-					module: `${testRealmURL}author`,
-					name: "Author"
-				} }
-			} };
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: testRealm2URL,
-				contents: {
-					...secondRealmAuthors,
-					"realm.json": realmConfigCardJSON({
-						name: "Second Search Entries Workspace",
-						iconURL: "https://boxel-images.boxel.ai/icons/Letter-o.png"
-					})
-				}
-			});
-		});
-	});
-	(0, import_qunit.test)("basic typed query returns entry summaries, not instances", async function(assert) {
-		let result = await runSearch({ query: { filter: {
-			eq: { firstName: "Mark" },
-			on: {
-				module: rri(`${testRealmURL}author`),
-				name: "Author"
-			}
-		} } });
-		assert.strictEqual(result.results.length, 1);
-		let row = result.results[0];
-		assert.strictEqual(row.url, `${testRealmURL}Author/mark`);
-		assert.strictEqual(row.kind, "card");
-		assert.strictEqual(row.cardTitle, "Mark Jackson");
-		assert.strictEqual(result.total, 1);
-		assert.false(result.incomplete, "every searched realm answered, so the result is complete");
-	});
-	(0, import_qunit.test)("spec rows carry ref, specType, and the full readMe", async function(assert) {
-		let result = await runSearch({ query: { filter: {
-			on: {
-				module: rri("@cardstack/base/spec"),
-				name: "Spec"
-			},
-			eq: {
-				specType: "card",
-				cardTitle: "Author"
-			}
-		} } });
-		assert.strictEqual(result.results.length, 1);
-		let row = result.results[0];
-		assert.strictEqual(row.url, `${testRealmURL}Spec/author`);
-		assert.strictEqual(row.specType, "card");
-		assert.deepEqual({
-			module: row.ref?.module,
-			name: row.ref?.name
-		}, {
-			module: `${testRealmURL}author`,
-			name: "Author"
-		});
-		assert.strictEqual(row.readMe, longReadMe, "readMe rides the result in full, untruncated");
-		assert.strictEqual(row.cardDescription, "Spec for the Author card definition");
-	});
-	(0, import_qunit.test)("scope narrows to files or cards", async function(assert) {
-		let filesResult = await runSearch({
-			query: { filter: { contains: { _title: "notes" } } },
-			scope: "files"
-		});
-		assert.ok(filesResult.results.some((r) => r.url === `${testRealmURL}notes.md`), "files scope surfaces the plain file");
-		assert.ok(filesResult.results.every((r) => r.kind === "file"), "files scope returns only file rows");
-		let notesRow = filesResult.results.find((r) => r.url === `${testRealmURL}notes.md`);
-		assert.strictEqual(notesRow?.name, "notes.md", "a file row carries its name as the display handle");
-		let cardsResult = await runSearch({
-			query: { filter: { contains: { _title: "notes" } } },
-			scope: "cards"
-		});
-		assert.ok(cardsResult.results.every((r) => r.kind === "card"), "cards scope returns only card rows");
-	});
-	(0, import_qunit.test)("invalid scope is rejected with the legal values", async function(assert) {
-		await assert.rejects(runSearch({
-			query: { filter: { matches: "xylophone" } },
-			scope: "modules"
-		}), /cards.*files.*all/);
-	});
-	(0, import_qunit.test)("default scope deduplicates a card against its own file row", async function(assert) {
-		let markRows = (await runSearch({ query: { filter: { matches: "xylophone" } } })).results.filter((r) => r.url.startsWith(`${testRealmURL}Author/mark`));
-		assert.strictEqual(markRows.length, 1, "the matching card appears once, not once per index row");
-	});
-	(0, import_qunit.test)("matches query yields relevance-sorted rows; non-matches yields none", async function(assert) {
-		let withMatches = await runSearch({ query: { filter: { matches: "xylophone" } } });
-		assert.ok(withMatches.results.length >= 1);
-		let relevances = withMatches.results.map((r) => r.matchRelevance);
-		assert.ok(relevances.every((r) => typeof r === "number"), "every row carries a numeric matchRelevance");
-		let sorted = [...relevances].sort((a, b) => b - a);
-		assert.deepEqual(relevances, sorted, "rows are sorted by relevance desc");
-		let withoutMatches = await runSearch({ query: { filter: {
-			eq: { firstName: "Mark" },
-			on: {
-				module: rri(`${testRealmURL}author`),
-				name: "Author"
-			}
-		} } });
-		assert.ok(withoutMatches.results.every((r) => r.matchRelevance == null), "no relevance without a matches term (and no 400 from the sort)");
-	});
-	(0, import_qunit.test)("a relevance sort carrying the filter type anchor still ranks spec rows", async function(assert) {
-		let specRef = {
-			module: rri("@cardstack/base/spec"),
-			name: "Spec"
-		};
-		let result = await runSearch({
-			query: {
-				filter: {
-					type: specRef,
-					matches: "writer"
-				},
-				sort: [{
-					by: "_matchRelevance",
-					on: specRef,
-					direction: "desc"
-				}]
-			},
-			realms: [testRealmURL]
-		});
-		assert.deepEqual(result.results.map((r) => r.url), [`${testRealmURL}Spec/author`]);
-		assert.strictEqual(typeof result.results[0].matchRelevance, "number");
-		assert.false(result.incomplete, "every searched realm answered");
-	});
-	(0, import_qunit.test)("a filter carrying several operators is rejected, naming them", async function(assert) {
-		let specRef = {
-			module: rri("@cardstack/base/spec"),
-			name: "Spec"
-		};
-		await assert.rejects(runSearch({ query: { filter: {
-			on: specRef,
-			eq: { specType: "card" },
-			contains: { cardTitle: "Author" }
-		} } }), /a filter may use only one operator, but found "eq", "contains"/);
-	});
-	(0, import_qunit.test)("empty operators beside the type anchor are dropped, not rejected", async function(assert) {
-		let specRef = {
-			module: rri("@cardstack/base/spec"),
-			name: "Spec"
-		};
-		let result = await runSearch({
-			query: { filter: {
-				eq: {},
-				any: [],
-				not: {},
-				every: [],
-				on: specRef,
-				type: specRef
-			} },
-			realms: [testRealmURL]
-		});
-		assert.deepEqual(result.results.map((r) => r.url), [`${testRealmURL}Spec/author`], "the type filter runs and finds exactly the spec");
-		assert.strictEqual(result.total, 1, "only the spec matches");
-	});
-	(0, import_qunit.test)("limit defaults to 5, is honored, and clamps at 10", async function(assert) {
-		let query = { filter: {
-			on: {
-				module: rri(`${testRealmURL}author`),
-				name: "Author"
-			},
-			contains: { lastName: "Example" }
-		} };
-		let defaulted = await runSearch({ query });
-		assert.strictEqual(defaulted.results.length, 5, "default limit is 5");
-		assert.strictEqual(defaulted.total, 12, "total reports the real count");
-		let three = await runSearch({
-			query,
-			limit: 3
-		});
-		assert.strictEqual(three.results.length, 3);
-		let clamped = await runSearch({
-			query,
-			limit: 50
-		});
-		assert.strictEqual(clamped.results.length, 10, "limit clamps to 10");
-	});
-	(0, import_qunit.test)("limit caps the merged result, not each realm", async function(assert) {
-		let capped = await runSearch({
-			query: { filter: {
-				on: {
-					module: rri(`${testRealmURL}author`),
-					name: "Author"
-				},
-				contains: { lastName: "Capped" }
-			} },
-			realms: [testRealmURL, testRealm2URL],
-			limit: 5
-		});
-		assert.strictEqual(capped.results.length, 5, "limit bounds the merged rows across both realms, not each realm");
-		assert.ok(capped.total > 5, "total still reports the full cross-realm match count");
-	});
-	(0, import_qunit.test)("realms input targets the given realm", async function(assert) {
-		let result = await runSearch({
-			query: { filter: {
-				eq: { firstName: "Mark" },
-				on: {
-					module: rri(`${testRealmURL}author`),
-					name: "Author"
-				}
-			} },
-			realms: [testRealmURL]
-		});
-		assert.strictEqual(result.results.length, 1);
-		assert.strictEqual(result.results[0].url, `${testRealmURL}Author/mark`);
-	});
-	(0, import_qunit.test)("realms input accepts a realm named by a registered prefix", async function(assert) {
-		let { virtualNetwork } = getService("network");
-		virtualNetwork.addRealmMapping("@test/mapped/", testRealmURL);
-		try {
-			let byURL = await runSearch({
-				query: {},
-				realms: [testRealmURL],
-				scope: "cards",
-				limit: 10
-			});
-			let byPrefix = await runSearch({
-				query: {},
-				realms: ["@test/mapped/"],
-				scope: "cards",
-				limit: 10
-			});
-			assert.ok(byURL.results.length > 0, "the realm has cards to find");
-			assert.deepEqual(byPrefix.results.map((row) => row.url).sort(), byURL.results.map((row) => row.url).sort(), "the prefix searches the realm it names");
-		} finally {
-			virtualNetwork.removeRealmMapping("@test/mapped/");
-		}
-	});
-	(0, import_qunit.test)("the tool module has a default export (skill declarations use name: default)", function(assert) {
-		assert.ok(SearchEntriesTool, "default export exists");
-	});
-	(0, import_qunit.module)("query composition", function() {
-		(0, import_qunit.test)("mixed-scope dedup wraps a non-narrowing filter", function(assert) {
-			let { query: composed } = composeSearchEntriesQuery({ filter: { matches: "xylophone" } }, "all");
-			assert.ok("every" in (composed.filter ?? {}), "filter is wrapped with the card-instance-file exclusion");
-		});
-		(0, import_qunit.test)("a narrowing positive type anchor skips the dedup wrap", function(assert) {
-			let filter = {
-				on: {
-					module: rri(`${testRealmURL}author`),
-					name: "Author"
-				},
-				eq: { firstName: "Mark" }
-			};
-			let { query: composed } = composeSearchEntriesQuery({ filter }, "all");
-			assert.deepEqual(composed.filter, filter, "filter passes through as-is");
-		});
-		(0, import_qunit.test)("an any-filter narrows only when every branch does", function(assert) {
-			let authorAnchor = {
-				on: {
-					module: rri(`${testRealmURL}author`),
-					name: "Author"
-				},
-				eq: { firstName: "Mark" }
-			};
-			let { query: mixed } = composeSearchEntriesQuery({ filter: { any: [authorAnchor, { matches: "xylophone" }] } }, "all");
-			assert.ok("every" in (mixed.filter ?? {}), "a partially-anchored any gains the dedup wrap");
-			let allNarrowing = { any: [authorAnchor, { type: {
-				module: rri(`${testRealmURL}author`),
-				name: "Author"
-			} }] };
-			let { query: narrowed } = composeSearchEntriesQuery({ filter: allNarrowing }, "all");
-			assert.deepEqual(narrowed.filter, allNarrowing, "an any whose every branch narrows passes through as-is");
-		});
-		(0, import_qunit.test)("explicit cards scope skips the dedup wrap", function(assert) {
-			let { query: composed } = composeSearchEntriesQuery({ filter: { matches: "xylophone" } }, "cards");
-			assert.deepEqual(composed.filter, { matches: "xylophone" });
-		});
-		(0, import_qunit.test)("a matches filter with no sort gains the relevance sort", function(assert) {
-			let { query: composed, addedRelevanceSort } = composeSearchEntriesQuery({ filter: { matches: "xylophone" } }, "cards");
-			assert.deepEqual(composed.sort, [{
-				by: "_matchRelevance",
-				direction: "desc"
-			}]);
-			assert.true(addedRelevanceSort, "the addition is reported so the tool re-sorts the merged rows");
-		});
-		(0, import_qunit.test)("an explicit sort and a matches-free filter stay untouched", function(assert) {
-			let { query: sorted, addedRelevanceSort } = composeSearchEntriesQuery({
-				filter: { matches: "xylophone" },
-				sort: [{
-					by: "cardTitle",
-					direction: "asc"
-				}]
-			}, "cards");
-			assert.deepEqual(sorted.sort, [{
-				by: "cardTitle",
-				direction: "asc"
-			}]);
-			assert.false(addedRelevanceSort, "a caller-chosen sort is never re-imposed client-side");
-			let { query: noMatches } = composeSearchEntriesQuery({ filter: { eq: { firstName: "Mark" } } }, "cards");
-			assert.strictEqual(noMatches.sort, void 0, "no relevance sort without a positive matches term");
-		});
-		(0, import_qunit.test)("a caller sort naming _matchRelevance is not re-imposed by the tool", function(assert) {
-			let { query: composed, addedRelevanceSort } = composeSearchEntriesQuery({
-				filter: { matches: "xylophone" },
-				sort: [{
-					by: "cardTitle",
-					direction: "asc"
-				}, {
-					by: "_matchRelevance",
-					direction: "asc"
-				}]
-			}, "cards");
-			assert.deepEqual(composed.sort, [{
-				by: "cardTitle",
-				direction: "asc"
-			}, {
-				by: "_matchRelevance",
-				direction: "asc"
-			}]);
-			assert.false(addedRelevanceSort, "relevance riding the rows must not trigger the client re-sort");
-		});
-		(0, import_qunit.test)("a negated matches term does not trigger the relevance sort", function(assert) {
-			let { query: composed } = composeSearchEntriesQuery({ filter: { every: [{ eq: { firstName: "Mark" } }, { not: { matches: "xylophone" } }] } }, "cards");
-			assert.strictEqual(composed.sort, void 0);
-		});
-	});
-});
-(0, import_qunit.module)("Integration | tools | search-entries | catalog telemetry", function(hooks) {
-	setupRenderingTest(hooks);
-	hooks.beforeEach(function() {
-		setCatalogRealmURL(getService("network").virtualNetwork.toURL("@cardstack/catalog/").href);
-	});
-	hooks.afterEach(function() {
-		resetCatalogRealmURL();
-	});
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: { "note.md": "# Note\n" }
-		});
-	});
-	(0, import_qunit.test)("a catalog search the assistant made is recorded, and one a card made is not", async function(assert) {
-		let { virtualNetwork } = getService("network");
-		let catalogURL = virtualNetwork.toURL("@cardstack/catalog/").href;
-		let federatedSearch = async (request) => {
-			if (!new URL(request.url).pathname.endsWith("/_federated-search")) return null;
-			return new Response(JSON.stringify({
-				data: [],
-				meta: {
-					page: { total: 2 },
-					realmTotals: { [catalogURL]: 2 }
-				}
-			}), { headers: { "content-type": SupportedMimeType.CardJson } });
-		};
-		virtualNetwork.mount(federatedSearch, { prepend: true });
-		let telemetry = getService("client-telemetry");
-		let recorded = [];
-		let recordEvent = telemetry.recordEvent;
-		telemetry.recordEvent = (event) => {
-			recorded.push(event);
-		};
-		try {
-			await getService("realm-server").ready;
-			let tool = new SearchEntriesTool(getService("tool-service").toolContext);
-			let input = {
-				query: { filter: { matches: "kanban" } },
-				realms: ["@cardstack/catalog/"]
-			};
-			await tool.execute({
-				...input,
-				roomId: "!room:localhost"
-			});
-			await tool.execute(input);
-			assert.deepEqual(recorded, [{
-				event_type: "catalog-search",
-				tool: "search-entries",
-				query_text: "kanban",
-				query_type: "",
-				total: 2,
-				returned: 0,
-				error: "",
-				realm: null
-			}]);
-		} finally {
-			telemetry.recordEvent = recordEvent;
-			virtualNetwork.unmount(federatedSearch);
-		}
-	});
-});
-//#endregion

package/bundled-test-harness/assets/search-google-images-test-LyhcB2f3.js

@@ -1,166 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { t as SearchGoogleImagesTool } from "./search-google-images-BhjU7t_7.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, R as setupRealmServerEndpoints, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/search-google-images-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Integration | tools | search-google-images", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	setupRealmServerEndpoints(hooks, [{
-		route: "_request-forward",
-		getResponse: async (req) => {
-			if ((await req.json()).url.includes("googleapis.com/customsearch/v1")) return new Response(JSON.stringify({
-				kind: "customsearch#search",
-				url: {
-					type: "application/json",
-					template: "https://www.googleapis.com/customsearch/v1?q={searchTerms}&num={count?}&start={startIndex?}&searchType={searchType}&key={key}&cx={cx?}"
-				},
-				queries: {
-					request: [{
-						title: "Google Custom Search - test",
-						totalResults: "2",
-						searchTerms: "test",
-						count: 2,
-						startIndex: 1,
-						inputEncoding: "utf8",
-						outputEncoding: "utf8",
-						safe: "off",
-						searchType: "image"
-					}],
-					nextPage: [{
-						title: "Google Custom Search - test",
-						totalResults: "2",
-						searchTerms: "test",
-						count: 2,
-						startIndex: 3,
-						inputEncoding: "utf8",
-						outputEncoding: "utf8",
-						safe: "off",
-						searchType: "image"
-					}]
-				},
-				context: { cardTitle: "boxel-search-image" },
-				searchInformation: {
-					searchTime: .5,
-					formattedSearchTime: "0.50",
-					totalResults: "2",
-					formattedTotalResults: "2"
-				},
-				items: [{
-					kind: "customsearch#result",
-					title: "Test Image 1",
-					htmlTitle: "<b>Test</b> Image 1",
-					link: "https://example.com/image1.jpg",
-					displayLink: "example.com",
-					snippet: "Test Image 1",
-					htmlSnippet: "<b>Test</b> Image 1",
-					mime: "image/jpeg",
-					fileFormat: "image/jpeg",
-					image: {
-						contextLink: "https://example.com/page1",
-						height: 600,
-						width: 800,
-						byteSize: 5e4,
-						thumbnailLink: "https://example.com/thumb1.jpg",
-						thumbnailHeight: 84,
-						thumbnailWidth: 150
-					}
-				}, {
-					kind: "customsearch#result",
-					title: "Test Image 2",
-					htmlTitle: "<b>Test</b> Image 2",
-					link: "https://example.com/image2.jpg",
-					displayLink: "example.com",
-					snippet: "Test Image 2",
-					htmlSnippet: "<b>Test</b> Image 2",
-					mime: "image/png",
-					fileFormat: "image/png",
-					image: {
-						contextLink: "https://example.com/page2",
-						height: 768,
-						width: 1024,
-						byteSize: 75e3,
-						thumbnailLink: "https://example.com/thumb2.jpg",
-						thumbnailHeight: 100,
-						thumbnailWidth: 150
-					}
-				}]
-			}), {
-				status: 200,
-				headers: { "Content-Type": "application/json" }
-			});
-			return new Response(JSON.stringify({ error: "Unknown endpoint" }), {
-				status: 404,
-				headers: { "Content-Type": "application/json" }
-			});
-		}
-	}]);
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		}));
-	});
-	(0, import_qunit.test)("successfully searches Google Images and returns results", async function(assert) {
-		const result = await new SearchGoogleImagesTool(getService("tool-service").toolContext).execute({
-			query: "test images",
-			maxResults: 5
-		});
-		assert.ok(result, "Command should return a result");
-		assert.strictEqual(result.images.length, 2, "Should return 2 images");
-		assert.strictEqual(result.totalResults, 2, "Should have 2 total results");
-		assert.strictEqual(result.searchTime, .5, "Should have correct search time");
-		assert.strictEqual(result.formattedTotalResults, "2", "Should have correct formatted total results");
-		assert.strictEqual(result.formattedSearchTime, "0.50", "Should have correct formatted search time");
-		assert.true(result.hasNextPage, "Should have next page");
-		assert.strictEqual(result.nextPageStartIndex, 3, "Should have correct next page start index");
-		assert.strictEqual(result.currentStartIndex, 1, "Should have correct current start index");
-		const firstImage = result.images[0];
-		assert.strictEqual(firstImage.title, "Test Image 1", "Should have correct title");
-		assert.strictEqual(firstImage.imageUrl, "https://example.com/image1.jpg", "Should have correct image URL");
-		assert.strictEqual(firstImage.thumbnailUrl, "https://example.com/thumb1.jpg", "Should have correct thumbnail URL");
-		assert.strictEqual(firstImage.contextUrl, "https://example.com/page1", "Should have correct context URL");
-		assert.strictEqual(firstImage.width, 800, "Should have correct width");
-		assert.strictEqual(firstImage.height, 600, "Should have correct height");
-		assert.strictEqual(firstImage.byteSize, 5e4, "Should have correct byte size");
-		assert.strictEqual(firstImage.thumbnailWidth, 150, "Should have correct thumbnail width");
-		assert.strictEqual(firstImage.thumbnailHeight, 84, "Should have correct thumbnail height");
-		assert.strictEqual(firstImage.mime, "image/jpeg", "Should have correct mime type");
-		assert.strictEqual(firstImage.fileFormat, "image/jpeg", "Should have correct file format");
-		assert.strictEqual(firstImage.displayLink, "example.com", "Should have correct display link");
-		assert.strictEqual(firstImage.snippet, "Test Image 1", "Should have correct snippet");
-	});
-	(0, import_qunit.test)("uses default maxResults when not provided", async function(assert) {
-		const result = await new SearchGoogleImagesTool(getService("tool-service").toolContext).execute({ query: "test images" });
-		assert.ok(result, "Command should return a result");
-		assert.strictEqual(result.images.length, 2, "Should return images");
-	});
-	(0, import_qunit.test)("limits maxResults to 10", async function(assert) {
-		const result = await new SearchGoogleImagesTool(getService("tool-service").toolContext).execute({
-			query: "test images",
-			maxResults: 20
-		});
-		assert.ok(result, "Command should return a result");
-		assert.strictEqual(result.images.length, 2, "Should return available images");
-	});
-	(0, import_qunit.test)("supports pagination with startIndex parameter", async function(assert) {
-		const result = await new SearchGoogleImagesTool(getService("tool-service").toolContext).execute({
-			query: "test images",
-			maxResults: 5,
-			startIndex: 3
-		});
-		assert.ok(result, "Command should return a result");
-		assert.strictEqual(result.currentStartIndex, 3, "Should have correct start index");
-		assert.strictEqual(result.images.length, 2, "Should return images");
-	});
-});
-//#endregion