@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/search-results-test-krtQQM57.js

@@ -0,0 +1,578 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { Ar as testRealmURL, Dr as testRRI, Ja as EntryResourceType, Po as isCardInstance, Xa as HtmlResourceType, Za as IconResourceType, eo as htmlResourceId } from "./runtime-common-ClpqhbwG.js";
+import { m as GetCardContextName, t as CardContextName } from "./constants-CqKWhRfY.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import { n as tracked } from "./tracking-800VJb8b.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { n as getCard } from "./card-resource-JGLjQUy6.js";
+import { r as provide } from "./dist-Ble0L9o7.js";
+import { t as SearchResults } from "./search-results-DrHTuVRZ.js";
+import { M as waitUntil, h as render, l as triggerEvent } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-DPQ0j2MD.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { A as field, a as CardDef, s as Component$1, w as contains } from "./card-api-Dzje0smT.js";
+import { t as string_default } from "./string-BHZZwNlZ.js";
+//#region tests/integration/components/search-results-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var TestContext = class extends Component {
+	get getCardFn() {
+		return getCard;
+	}
+	static {
+		decorateMethodV2(this.prototype, "getCardFn", [provide(GetCardContextName)]);
+	}
+	get cardContext() {}
+	static {
+		decorateMethodV2(this.prototype, "cardContext", [provide(CardContextName)]);
+	}
+	static {
+		setComponentTemplate(templateFactory({
+			"id": "NZAioTAH",
+			"block": "[[[18,1,null]],[\"&default\"],[\"yield\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+			"isStrictMode": true
+		}), this);
+	}
+};
+var QueryState = class {
+	static {
+		decorateFieldV2(this.prototype, "query", [tracked], function() {});
+	}
+	#query = (initializeDeferredDecorator(this, "query"), void 0);
+};
+var bookRef = {
+	module: testRRI("book"),
+	name: "Book"
+};
+var BOOK_1 = `${testRealmURL}books/1`;
+var BOOK_2 = `${testRealmURL}books/2`;
+var CSS_HREF = `${testRealmURL}book.gts.abc123.glimmer-scoped.css`;
+var BOOK_ICON_ID = `${bookRef.module}/Book`;
+var BOOK_ICON_HTML = "<svg data-test-book-type-icon></svg>";
+function renderingIdFor(url) {
+	return htmlResourceId({
+		url,
+		format: "fitted",
+		renderType: bookRef
+	});
+}
+function htmlEntryResource(url) {
+	return {
+		type: EntryResourceType,
+		id: url,
+		relationships: { html: { data: [{
+			type: HtmlResourceType,
+			id: renderingIdFor(url)
+		}] } }
+	};
+}
+function htmlIncluded(url, html, isError = false) {
+	return [{
+		type: HtmlResourceType,
+		id: renderingIdFor(url),
+		attributes: {
+			html,
+			cardType: "Book",
+			isError,
+			format: "fitted",
+			renderType: bookRef
+		},
+		relationships: { styles: { data: [{
+			type: "css",
+			id: "deadbeef"
+		}] } }
+	}, {
+		type: "css",
+		id: "deadbeef",
+		attributes: { href: CSS_HREF }
+	}];
+}
+function itemEntryResource(url) {
+	return {
+		type: EntryResourceType,
+		id: url,
+		relationships: { item: { data: {
+			type: "card",
+			id: url
+		} } }
+	};
+}
+function bookItem(url, title, opts) {
+	return {
+		type: "card",
+		id: url,
+		attributes: {
+			title,
+			status: "ready"
+		},
+		relationships: {},
+		meta: {
+			adoptsFrom: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			...opts?.sparseFields ? { sparseFields: opts.sparseFields } : {}
+		},
+		links: { self: url }
+	};
+}
+function errorItem(url, message) {
+	return {
+		type: "card",
+		id: url,
+		meta: {
+			adoptsFrom: {
+				module: testRRI("book"),
+				name: "Book"
+			},
+			error: {
+				type: "instance-error",
+				error: {
+					title: "Card Error",
+					status: 500,
+					message,
+					additionalErrors: null
+				}
+			}
+		},
+		links: { self: url }
+	};
+}
+function htmlIncludedNoLastKnownGood(url) {
+	return [{
+		type: HtmlResourceType,
+		id: renderingIdFor(url),
+		attributes: {
+			cardType: "Book",
+			isError: true,
+			format: "fitted",
+			renderType: bookRef
+		},
+		relationships: { styles: { data: [] } }
+	}];
+}
+(0, import_qunit.module)("Integration | Component | search-results", function(hooks) {
+	let loader;
+	let storeService;
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		loader = getService("loader-service").loader;
+		storeService = getService("store");
+		class Book extends CardDef {
+			static displayName = "Book";
+			static {
+				decorateFieldV2(this.prototype, "title", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#title = (initializeDeferredDecorator(this, "title"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "status", [field], function() {
+					return contains(string_default);
+				});
+			}
+			#status = (initializeDeferredDecorator(this, "status"), void 0);
+			static fitted = class Fitted extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "pjMPxLg3",
+						"block": "[[[10,0],[14,0,\"live-book\"],[14,\"data-test-live-book\",\"\"],[12],[1,\"\\n  Live:\\n  \"],[8,[30,1,[\"title\"]],null,null,null],[1,\"\\n\"],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+			static embedded = class Embedded extends Component$1 {
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "/2deeGeK",
+						"block": "[[[10,0],[14,0,\"embedded-book\"],[14,\"data-test-embedded-book\",\"\"],[12],[1,\"\\n  Embedded:\\n  \"],[8,[30,1,[\"title\"]],null,null,null],[1,\"\\n\"],[13]],[\"@fields\"],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {
+				"book.gts": { Book },
+				"books/1.json": new Book({
+					title: "Mango",
+					status: "ready"
+				}),
+				"books/2.json": new Book({
+					title: "Van Gogh",
+					status: "ready"
+				})
+			}
+		});
+		await getService("realm").login(testRealmURL);
+	});
+	function stubSearchEntries(doc) {
+		let originalSearchEntries = storeService.searchEntries.bind(storeService);
+		storeService.searchEntries = async () => doc;
+		let originalImport = loader.import.bind(loader);
+		loader.import = async (url) => url === CSS_HREF ? {} : originalImport(url);
+		return () => {
+			storeService.searchEntries = originalSearchEntries;
+			loader.import = originalImport;
+		};
+	}
+	(0, import_qunit.test)("renders prerendered HTML inert and hydrates it lazily on hover", async function(assert) {
+		let query = {
+			filter: { "item.on": bookRef },
+			realms: [testRealmURL]
+		};
+		await render(setComponentTemplate(templateFactory({
+			"id": "lsnvufTK",
+			"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"hover\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+			"scope": () => [
+				TestContext,
+				SearchResults,
+				query
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitUntil(() => Boolean(document.querySelector("[data-test-search-result]")));
+		assert.dom(`[data-test-search-result="${BOOK_1}"]`).exists("the first book result rendered");
+		assert.dom(`[data-test-search-result="${BOOK_2}"]`).exists("the second book result rendered");
+		assert.dom(`[data-test-hydratable-card="${BOOK_1}"][data-hydration="hover"]`).exists("an html-backed result starts inert with the hover gesture wired");
+		assert.notOk(isCardInstance(storeService.peek(BOOK_1)), "an html-only result is not deposited into the store");
+		await triggerEvent(`[data-test-hydratable-card="${BOOK_1}"]`, "mouseenter");
+		assert.dom(`[data-test-hydratable-card="${BOOK_1}"][data-hydration="hydrated"]`).exists("hovering hydrates the result into a live card");
+		assert.ok(isCardInstance(storeService.peek(BOOK_1)), "the hydration GET deposited the card into the store");
+	});
+	(0, import_qunit.test)("renders a heterogeneous stream: an html row inert, an item-only row live", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [htmlEntryResource(BOOK_1), itemEntryResource(BOOK_2)],
+			included: [...htmlIncluded(BOOK_1, `<div data-test-inert-book>Mango</div>`), bookItem(BOOK_2, "Van Gogh")],
+			meta: {
+				page: { total: 2 },
+				htmlQuery: { eq: {
+					format: "fitted",
+					renderType: bookRef
+				} }
+			}
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "lsnvufTK",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"hover\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-live-book]")));
+			assert.dom(`[data-test-hydratable-card="${BOOK_1}"][data-hydration="hover"]`).exists("the html row is inert");
+			assert.dom("[data-test-inert-book]").exists("it shows its prerendered markup");
+			assert.dom(`[data-test-hydratable-card="${BOOK_2}"][data-hydration="hydrated"]`).exists("the item-only row renders live without a gesture");
+			assert.dom("[data-test-live-book]").hasText("Live: Van Gogh");
+			assert.ok(isCardInstance(storeService.peek(BOOK_2)), "the full item was inflated into the store");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("stamps the type icon from the deduped icon resource, shared across rows", async function(assert) {
+		let withIcon = (url) => ({
+			type: EntryResourceType,
+			id: url,
+			relationships: {
+				html: { data: [{
+					type: HtmlResourceType,
+					id: renderingIdFor(url)
+				}] },
+				icon: { data: {
+					type: IconResourceType,
+					id: BOOK_ICON_ID
+				} }
+			}
+		});
+		let restore = stubSearchEntries({
+			data: [withIcon(BOOK_1), withIcon(BOOK_2)],
+			included: [
+				...htmlIncluded(BOOK_1, `<div data-test-inert-book>Mango</div>`),
+				...htmlIncluded(BOOK_2, `<div data-test-inert-book>Van Gogh</div>`),
+				{
+					type: IconResourceType,
+					id: BOOK_ICON_ID,
+					attributes: {
+						iconHtml: BOOK_ICON_HTML,
+						displayName: "Book",
+						codeRef: bookRef
+					}
+				}
+			],
+			meta: {
+				page: { total: 2 },
+				htmlQuery: { eq: {
+					format: "fitted",
+					renderType: bookRef
+				} }
+			}
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "xksbYz5O",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"none\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-search-result]")));
+			for (let url of [BOOK_1, BOOK_2]) assert.dom(`[data-test-hydratable-card="${url}"]`).hasAttribute("data-card-type-icon-html", BOOK_ICON_HTML, `${url} carries the deduped type icon as a data attribute`);
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("a live fallback renders at the format the query selected", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [itemEntryResource(BOOK_1)],
+			included: [bookItem(BOOK_1, "Mango")],
+			meta: {
+				page: { total: 1 },
+				htmlQuery: { eq: {
+					format: "embedded",
+					renderType: bookRef
+				} }
+			}
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "GxK4Chfk",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\"],[[32,2]]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-embedded-book]")));
+			assert.dom("[data-test-embedded-book]").hasText("Embedded: Mango", "the live fallback rendered at embedded");
+			assert.dom("[data-test-live-book]").doesNotExist("it did not fall back to the fitted format");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("selective Store inflate: a full item is deposited, a sparse item never is", async function(assert) {
+		await storeService.inflateSearchEntryItem(bookItem(BOOK_1, "Mango"));
+		assert.ok(isCardInstance(storeService.peek(BOOK_1)), "a full item is deposited into the store");
+		await storeService.inflateSearchEntryItem(bookItem(BOOK_2, "Van Gogh", { sparseFields: ["title"] }));
+		assert.notOk(isCardInstance(storeService.peek(BOOK_2)), "a sparse item is never deposited");
+	});
+	(0, import_qunit.test)("the component inflates a full item row into the store", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [itemEntryResource(BOOK_1)],
+			included: [bookItem(BOOK_1, "Mango")],
+			meta: { page: { total: 1 } }
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				fields: { entry: ["item"] },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "GxK4Chfk",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\"],[[32,2]]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => isCardInstance(storeService.peek(BOOK_1)));
+			assert.ok(isCardInstance(storeService.peek(BOOK_1)), "the full item row was deposited by the selective inflate");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("an error rendering never hydrates", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [htmlEntryResource(BOOK_1)],
+			included: htmlIncluded(BOOK_1, `<div data-test-inert-book data-is-error='true'>Last known good</div>`, true),
+			meta: {
+				page: { total: 1 },
+				htmlQuery: { eq: {
+					format: "fitted",
+					renderType: bookRef
+				} }
+			}
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "lsnvufTK",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"hover\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-inert-book]")));
+			assert.dom(`[data-test-hydratable-card="${BOOK_1}"][data-hydration="none"]`).exists("an error row is forced to none regardless of @mode");
+			await triggerEvent(`[data-test-hydratable-card="${BOOK_1}"]`, "mouseenter");
+			assert.dom("[data-test-inert-book]").exists("the error rendering stays inert after hover");
+			assert.notOk(isCardInstance(storeService.peek(BOOK_1)), "no hydration GET fired for an error row");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("an error item with no html falls through to the host error component", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [itemEntryResource(BOOK_1)],
+			included: [errorItem(BOOK_1, "Boom: failed to render")],
+			meta: { page: { total: 1 } }
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "lsnvufTK",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"hover\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-search-result-error]")));
+			assert.dom(`[data-test-search-result-error="${BOOK_1}"]`).exists("the host error component renders for an error item").containsText("Boom: failed to render", "it surfaces the error doc message");
+			assert.dom(`[data-test-hydratable-card="${BOOK_1}"]`).doesNotExist("an error item is not a hydratable card");
+			assert.notOk(isCardInstance(storeService.peek(BOOK_1)), "an error item is never deposited into the store");
+			await triggerEvent(`[data-test-search-result-error="${BOOK_1}"]`, "mouseenter");
+			assert.notOk(isCardInstance(storeService.peek(BOOK_1)), "hovering the host error component fires no hydration GET");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("an error rendering with no last-known-good html falls through to the host error component", async function(assert) {
+		let restore = stubSearchEntries({
+			data: [htmlEntryResource(BOOK_1)],
+			included: htmlIncludedNoLastKnownGood(BOOK_1),
+			meta: {
+				page: { total: 1 },
+				htmlQuery: { eq: {
+					format: "fitted",
+					renderType: bookRef
+				} }
+			}
+		});
+		try {
+			let query = {
+				filter: { "item.on": bookRef },
+				realms: [testRealmURL]
+			};
+			await render(setComponentTemplate(templateFactory({
+				"id": "lsnvufTK",
+				"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\",\"@mode\"],[[32,2],\"hover\"]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+				"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+				"scope": () => [
+					TestContext,
+					SearchResults,
+					query
+				],
+				"isStrictMode": true
+			}), templateOnly()));
+			await waitUntil(() => Boolean(document.querySelector("[data-test-search-result-error]")));
+			assert.dom(`[data-test-search-result-error="${BOOK_1}"]`).exists("the host error component renders when there is nothing to show").containsText("could not be rendered", "it shows the generic message when no error doc rode along");
+			assert.notOk(isCardInstance(storeService.peek(BOOK_1)), "a bare error rendering never enters the store");
+		} finally {
+			restore();
+		}
+	});
+	(0, import_qunit.test)("yields a results object to a block consumer", async function(assert) {
+		let query = {
+			filter: { "item.on": bookRef },
+			realms: [testRealmURL]
+		};
+		await render(setComponentTemplate(templateFactory({
+			"id": "gS2OSi+c",
+			"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\"],[[32,2]]],[[\"default\"],[[[[1,\"\\n    \"],[10,0],[14,\"data-test-total\",\"\"],[12],[1,[30,1,[\"meta\",\"page\",\"total\"]]],[13],[1,\"\\n    \"],[10,0],[14,\"data-test-count\",\"\"],[12],[1,[30,1,[\"entries\",\"length\"]]],[13],[1,\"\\n\"],[42,[28,[31,1],[[28,[31,1],[[30,1,[\"entries\"]]],null]],null],\"id\",[[[1,\"      \"],[10,0],[14,0,\"custom\"],[15,\"data-test-custom\",[30,2,[\"id\"]]],[12],[1,\"\\n        \"],[8,[30,2,[\"component\"]],null,null,null],[1,\"\\n      \"],[13],[1,\"\\n\"]],[2]],null],[1,\"  \"]],[1]]]]],[1,\"\\n\"]],[]]]]]],[\"results\",\"entry\"],[\"each\",\"-track-array\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+			"scope": () => [
+				TestContext,
+				SearchResults,
+				query
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitUntil(() => Boolean(document.querySelector("[data-test-custom]")));
+		assert.dom("[data-test-total]").hasText("2", "the page total is yielded");
+		assert.dom("[data-test-count]").hasText("2", "both entries are yielded");
+		assert.dom(`[data-test-custom="${BOOK_1}"] [data-test-hydratable-card]`).exists("the consumer renders each entry.component");
+	});
+	(0, import_qunit.test)("an undefined query renders nothing, then activates when set", async function(assert) {
+		let state = new QueryState();
+		await render(setComponentTemplate(templateFactory({
+			"id": "y4Veyiow",
+			"block": "[[[8,[32,0],null,null,[[\"default\"],[[[[1,\"\\n  \"],[8,[32,1],null,[[\"@query\"],[[32,2,[\"query\"]]]],null],[1,\"\\n\"]],[]]]]]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-results-test.gts",
+			"scope": () => [
+				TestContext,
+				SearchResults,
+				state
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-search-result]").doesNotExist("an idle query renders no results");
+		state.query = {
+			filter: { "item.on": bookRef },
+			realms: [testRealmURL]
+		};
+		await waitUntil(() => Boolean(document.querySelector("[data-test-search-result]")));
+		assert.dom("[data-test-search-result]").exists({ count: 2 }, "setting the query activates the search");
+	});
+	hooks.afterEach(function() {
+		getService("network").virtualNetwork.removeRealmMapping("@test-prefix/");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/search-selection-menu-test-DoqSbez7.js

@@ -0,0 +1,108 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import { a as get, t as array } from "./helper-m6jA5HmU.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { d as click, h as render, o as waitFor } from "./dist-BOAdzfkP.js";
+import { a as VIEW_OPTIONS, i as SORT_OPTIONS, t as SearchResultHeader } from "./search-result-header-UFkdo0Bx.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { lt as setupRenderingTest } from "./mock-matrix-DPQ0j2MD.js";
+//#region tests/integration/components/search-selection-menu-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var noop = () => {};
+(0, import_qunit.module)("Integration | search/search-result-header (selection menu)", function(hooks) {
+	setupRenderingTest(hooks);
+	(0, import_qunit.test)("the \"N Selected\" trigger renders the Adorn teal checkmark treatment", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "xy/4Q9DY",
+			"block": "[[[8,[32,0],null,[[\"@summaryText\",\"@viewOptions\",\"@activeViewId\",\"@activeSort\",\"@sortOptions\",\"@onChangeView\",\"@onChangeSort\",\"@multiSelect\",\"@selectedCards\",\"@allCards\",\"@onSelectAll\",\"@onDeselectAll\"],[\"2 results across 1 realm\",[32,1],\"grid\",[28,[32,2],[[32,3],0],null],[32,3],[32,4],[32,4],true,[28,[32,5],[\"a\",\"b\"],null],[28,[32,5],[\"a\",\"b\",\"c\"],null],[32,4],[32,4]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-selection-menu-test.gts",
+			"scope": () => [
+				SearchResultHeader,
+				VIEW_OPTIONS,
+				get,
+				SORT_OPTIONS,
+				noop,
+				array
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-selection-dropdown-trigger]").hasText("2", "trigger shows the selected count only");
+		assert.dom("[data-test-selection-dropdown-trigger]").hasAttribute("aria-label", "Selection menu, 2 cards selected", "trigger spells out the control and count for assistive tech");
+		assert.dom("[data-test-selection-dropdown-trigger] svg circle").exists("trigger renders the dark-circle-with-teal-check icon");
+	});
+	(0, import_qunit.test)("the selection menu opens with an inert \"N Selected\" header above Select/Deselect All", async function(assert) {
+		let selectAllArg;
+		let deselectedAll = false;
+		const onSelectAll = (cards) => selectAllArg = cards;
+		const onDeselectAll = () => deselectedAll = true;
+		await render(setComponentTemplate(templateFactory({
+			"id": "kBo7Ctn3",
+			"block": "[[[8,[32,0],null,[[\"@summaryText\",\"@viewOptions\",\"@activeViewId\",\"@activeSort\",\"@sortOptions\",\"@onChangeView\",\"@onChangeSort\",\"@multiSelect\",\"@selectedCards\",\"@allCards\",\"@onSelectAll\",\"@onDeselectAll\"],[\"3 results across 1 realm\",[32,1],\"grid\",[28,[32,2],[[32,3],0],null],[32,3],[32,4],[32,4],true,[28,[32,5],[\"a\",\"b\"],null],[28,[32,5],[\"a\",\"b\",\"c\"],null],[32,6],[32,7]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-selection-menu-test.gts",
+			"scope": () => [
+				SearchResultHeader,
+				VIEW_OPTIONS,
+				get,
+				SORT_OPTIONS,
+				noop,
+				array,
+				onSelectAll,
+				onDeselectAll
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		await click("[data-test-selection-dropdown-trigger]");
+		await waitFor("[data-test-boxel-menu-item-text=\"2 Selected\"]");
+		assert.dom("[data-test-boxel-menu-item-header]").exists({ count: 1 }, "the menu has exactly one inert header item");
+		assert.dom("[data-test-boxel-menu-item-header]").hasText("2 Selected", "the header echoes the selected count");
+		assert.dom("[data-test-boxel-menu-item-text=\"Select All\"]").exists("Select All item is present");
+		assert.dom("[data-test-boxel-menu-item-text=\"Deselect All\"]").exists("Deselect All item is present");
+		await click("[data-test-boxel-menu-item-text=\"Select All\"]");
+		assert.deepEqual(selectAllArg, [
+			"a",
+			"b",
+			"c"
+		], "Select All forwards every card");
+		await click("[data-test-selection-dropdown-trigger]");
+		await waitFor("[data-test-boxel-menu-item-text=\"Deselect All\"]");
+		await click("[data-test-boxel-menu-item-text=\"Deselect All\"]");
+		assert.true(deselectedAll, "Deselect All clears the selection");
+	});
+	(0, import_qunit.test)("the selection menu is hidden when no cards are selected", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "ZJ3UIq0P",
+			"block": "[[[8,[32,0],null,[[\"@summaryText\",\"@viewOptions\",\"@activeViewId\",\"@activeSort\",\"@sortOptions\",\"@onChangeView\",\"@onChangeSort\",\"@multiSelect\",\"@selectedCards\",\"@allCards\",\"@onSelectAll\",\"@onDeselectAll\"],[\"2 results across 1 realm\",[32,1],\"grid\",[28,[32,2],[[32,3],0],null],[32,3],[32,4],[32,4],true,[32,5],[28,[32,5],[\"a\",\"b\",\"c\"],null],[32,4],[32,4]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-selection-menu-test.gts",
+			"scope": () => [
+				SearchResultHeader,
+				VIEW_OPTIONS,
+				get,
+				SORT_OPTIONS,
+				noop,
+				array
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-selection-dropdown-trigger]").doesNotExist();
+	});
+	(0, import_qunit.test)("the selection menu is hidden when not in multi-select mode", async function(assert) {
+		await render(setComponentTemplate(templateFactory({
+			"id": "z2b/zBc2",
+			"block": "[[[8,[32,0],null,[[\"@summaryText\",\"@viewOptions\",\"@activeViewId\",\"@activeSort\",\"@sortOptions\",\"@onChangeView\",\"@onChangeSort\"],[\"2 results across 1 realm\",[32,1],\"grid\",[28,[32,2],[[32,3],0],null],[32,3],[32,4],[32,4]]],null]],[],[]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/components/search-selection-menu-test.gts",
+			"scope": () => [
+				SearchResultHeader,
+				VIEW_OPTIONS,
+				get,
+				SORT_OPTIONS,
+				noop
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		assert.dom("[data-test-selection-dropdown-trigger]").doesNotExist();
+	});
+});
+//#endregion