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

package/bundled-test-harness/assets/can-invoke-test-DJi7jMaU.js

@@ -0,0 +1,455 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { jc as isCardErrorJSONAPI } from "./runtime-common-BTaLJEw-.js";
+import { T as rri } from "./paths-C9-NYXnM.js";
+import { O as baseRealm } from "./constants-Icc0nFW-.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { t as Service } from "./service-LFpJ8EEP.js";
+import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
+import "./component-BJO47HTh.js";
+import { t as Component } from "./dist-CkA1rgqO.js";
+import "./template-factory-ds9s0u8l.js";
+import { t as templateOnly } from "./template-only-6nVzLWF-.js";
+import { t as OperatorModeContainer } from "./container-CEslVSTe.js";
+import { M as waitUntil, T as settled, h as render, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, F as setupLocalIndexing, P as setupIntegrationTestRealm, a as SYSTEM_CARD_FIXTURE_CONTENTS, lt as setupRenderingTest, ot as setupOperatorModeStateCleanup, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { a as CardDef } from "./card-api-Cc8uZunB.js";
+import { n as renderComponent } from "./render-component-B15Z0e2v.js";
+//#region tests/integration/can-invoke-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var REALM = "http://test-realm/test/";
+var OTHER = "http://test-realm/other/";
+var realmUnderTest = {
+	sent: [],
+	allow: /* @__PURE__ */ new Set(),
+	holding: void 0,
+	release: void 0,
+	failing: false,
+	lookedUp: [],
+	listeners: /* @__PURE__ */ new Map(),
+	hold() {
+		this.holding = new Promise((resolve) => {
+			this.release = () => {
+				this.holding = void 0;
+				this.release = void 0;
+				resolve();
+			};
+		});
+	}
+};
+var FakeNetwork = class extends Service {
+	authedFetch = async (url, init) => {
+		let { checks } = JSON.parse(init.body);
+		realmUnderTest.sent.push({
+			url,
+			checks
+		});
+		if (realmUnderTest.holding) await realmUnderTest.holding;
+		if (realmUnderTest.failing) return { ok: false };
+		return {
+			ok: true,
+			json: async () => ({ checks: checks.map((check) => ({
+				...check,
+				allowed: realmUnderTest.allow.has(`${check.operation} ${String(check.target)}`)
+			})) })
+		};
+	};
+};
+var FakeRealm = class extends Service {
+	realmOf = (id) => [REALM, OTHER].find((realm) => id.startsWith(realm));
+	info = (url) => {
+		realmUnderTest.lookedUp.push(url);
+		return {};
+	};
+};
+var FakeMessageService = class extends Service {
+	subscribe(realmURL, cb) {
+		let listeners = realmUnderTest.listeners.get(realmURL) ?? [];
+		listeners.push(cb);
+		realmUnderTest.listeners.set(realmURL, listeners);
+		return () => {
+			realmUnderTest.listeners.set(realmURL, (realmUnderTest.listeners.get(realmURL) ?? []).filter((l) => l !== cb));
+		};
+	}
+};
+function indexed(realmURL, invalidations) {
+	for (let listener of realmUnderTest.listeners.get(realmURL) ?? []) listener({
+		eventName: "index",
+		indexType: "incremental",
+		invalidations,
+		realmURL
+	});
+}
+function cardAt(id) {
+	return { id };
+}
+(0, import_qunit.module)("Integration | canInvoke", function(hooks) {
+	setupRenderingTest(hooks);
+	let service;
+	hooks.beforeEach(function() {
+		realmUnderTest.sent = [];
+		realmUnderTest.allow = /* @__PURE__ */ new Set();
+		realmUnderTest.holding = void 0;
+		realmUnderTest.release = void 0;
+		realmUnderTest.failing = false;
+		realmUnderTest.lookedUp = [];
+		realmUnderTest.listeners = /* @__PURE__ */ new Map();
+		this.owner.register("service:network", FakeNetwork);
+		this.owner.register("service:realm", FakeRealm);
+		this.owner.register("service:message-service", FakeMessageService);
+		service = this.owner.lookup("service:capabilities");
+	});
+	(0, import_qunit.test)("the reads one render pass makes go out as one request per realm", async function(assert) {
+		let cards = Array.from({ length: 30 }, (_, index) => `${REALM}classrooms/room-${index}`);
+		for (let id of cards) for (let operation of [
+			"read",
+			"rename",
+			"delete"
+		]) assert.strictEqual(service.canInvoke(operation, cardAt(id)), void 0, "nothing is known before the realm has been asked");
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 1, "one request");
+		assert.strictEqual(realmUnderTest.sent[0].url, `${REALM}_capabilities`, "to the realm that decides them");
+		assert.strictEqual(realmUnderTest.sent[0].checks.length, 90, "carrying all ninety pairs");
+	});
+	(0, import_qunit.test)("a pass spanning two realms sends one request to each", async function(assert) {
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		service.canInvoke("read", cardAt(`${OTHER}b`));
+		await settled();
+		assert.deepEqual(realmUnderTest.sent.map((request) => request.url).sort(), [`${OTHER}_capabilities`, `${REALM}_capabilities`], "a check is addressed to the realm whose policy decides it");
+	});
+	(0, import_qunit.test)("a pass that enrols more than the cap is split rather than refused", async function(assert) {
+		for (let index = 0; index < 101; index++) service.canInvoke("read", cardAt(`${REALM}card-${index}`));
+		await settled();
+		assert.deepEqual(realmUnderTest.sent.map((request) => request.checks.length), [100, 1], "so the coalescing cannot carry a request past the cap the realm enforces");
+	});
+	(0, import_qunit.test)("an answer lands on the pair that was asked about and on no other", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}granted`);
+		service.canInvoke("read", cardAt(`${REALM}granted`));
+		service.canInvoke("read", cardAt(`${REALM}denied`));
+		service.canInvoke("rename", cardAt(`${REALM}granted`));
+		await settled();
+		assert.true(service.canInvoke("read", cardAt(`${REALM}granted`)));
+		assert.false(service.canInvoke("read", cardAt(`${REALM}denied`)));
+		assert.false(service.canInvoke("rename", cardAt(`${REALM}granted`)), "the same card under another operation is a different question");
+		assert.strictEqual(realmUnderTest.sent.length, 1, "and an answered pair is not asked again");
+	});
+	(0, import_qunit.test)("a pair already in flight is not asked a second time", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		realmUnderTest.hold();
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		await Promise.resolve();
+		await Promise.resolve();
+		assert.strictEqual(realmUnderTest.sent.length, 1, "the request is in flight");
+		assert.strictEqual(service.canInvoke("read", cardAt(`${REALM}a`)), void 0, "a re-render while it is in flight still reads \"not known\"");
+		realmUnderTest.release();
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 1, "and enrolled nothing further");
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)));
+	});
+	(0, import_qunit.test)("a card with no id asks nothing, and a card in a realm this session does not know waits for its realm to be looked up", async function(assert) {
+		assert.strictEqual(service.canInvoke("read", {}), void 0, "an unsaved card has no stored state for a predicate to read");
+		assert.strictEqual(service.canInvoke("read", cardAt("http://elsewhere/a")), void 0, "a loaded card whose realm is not known has no realm to be asked yet");
+		assert.strictEqual(service.canInvoke("read", "http://elsewhere/b"), void 0, "and nor does a URL");
+		await settled();
+		assert.deepEqual(realmUnderTest.sent, [], "none enrolled a pair");
+		assert.deepEqual(realmUnderTest.lookedUp, ["http://elsewhere/a", "http://elsewhere/b"], "each one’s realm is looked up, so a later read can address it");
+	});
+	(0, import_qunit.test)("nothing is asked or answered inside a prerender", async function(assert) {
+		globalThis.__boxelPrerenderApp = true;
+		try {
+			assert.strictEqual(service.canInvoke("read", cardAt(`${REALM}a`)), void 0, "the prerender app is not the session the HTML it produces is served to");
+			await settled();
+			assert.deepEqual(realmUnderTest.sent, [], "so it asks nothing");
+		} finally {
+			delete globalThis.__boxelPrerenderApp;
+		}
+	});
+	(0, import_qunit.test)("a request that fails leaves the pair unanswered rather than denied", async function(assert) {
+		realmUnderTest.failing = true;
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 1, "the realm was asked");
+		realmUnderTest.failing = false;
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		assert.strictEqual(service.canInvoke("read", cardAt(`${REALM}a`)), void 0, "a realm that could not answer has said nothing about whether the caller may");
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 2, "so the next read of the pair asks again");
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)), "and takes the answer the realm gives this time");
+	});
+	(0, import_qunit.test)("the session ending drops every answer it held", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		await settled();
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)));
+		service.resetState();
+		assert.strictEqual(service.canInvoke("read", cardAt(`${REALM}a`)), void 0, "who is asking is half the question, so the next read asks again");
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 2, "and it was asked again");
+	});
+	(0, import_qunit.test)("a pair read while another request is in flight goes out as soon as that request is under way", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		realmUnderTest.allow.add(`read ${REALM}b`);
+		realmUnderTest.hold();
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		await waitUntil(() => realmUnderTest.sent.length === 1);
+		service.canInvoke("read", cardAt(`${REALM}b`));
+		await waitUntil(() => realmUnderTest.sent.length === 2);
+		assert.deepEqual(realmUnderTest.sent.map((request) => request.checks.map((check) => check.target)), [[`${REALM}a`], [`${REALM}b`]], "the second pair did not wait on a request that was never going to carry it");
+		realmUnderTest.release();
+		await settled();
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)));
+		assert.true(service.canInvoke("read", cardAt(`${REALM}b`)));
+	});
+	(0, import_qunit.test)("a reply to a session that has ended is dropped", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		realmUnderTest.hold();
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		await waitUntil(() => realmUnderTest.sent.length === 1);
+		service.resetState();
+		realmUnderTest.allow.delete(`read ${REALM}a`);
+		realmUnderTest.release();
+		await settled();
+		assert.strictEqual(service.canInvoke("read", cardAt(`${REALM}a`)), void 0, "the earlier session’s answer did not land in this one");
+		await settled();
+		assert.strictEqual(realmUnderTest.sent.length, 2, "this session asked");
+		assert.false(service.canInvoke("read", cardAt(`${REALM}a`)), "and holds its own answer");
+	});
+	(0, import_qunit.test)("an index event naming a card asks again about it, and about nothing else", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}a`);
+		realmUnderTest.allow.add(`read ${REALM}b`);
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		service.canInvoke("read", cardAt(`${REALM}b`));
+		await settled();
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)));
+		realmUnderTest.allow.delete(`read ${REALM}a`);
+		realmUnderTest.hold();
+		indexed(REALM, [`${REALM}a`]);
+		await waitUntil(() => realmUnderTest.sent.length === 2);
+		assert.deepEqual(realmUnderTest.sent[1].checks.map((check) => check.target), [`${REALM}a`], "only the card the pass changed is asked about again");
+		assert.true(service.canInvoke("read", cardAt(`${REALM}a`)), "the held answer is served until the new one lands, so nothing flickers");
+		realmUnderTest.release();
+		await settled();
+		assert.false(service.canInvoke("read", cardAt(`${REALM}a`)), "and the new one replaces it");
+		assert.true(service.canInvoke("read", cardAt(`${REALM}b`)));
+	});
+	(0, import_qunit.test)("an index event that moves the realm’s config asks again about every pair in the realm", async function(assert) {
+		service.canInvoke("read", cardAt(`${REALM}a`));
+		service.canInvoke("delete", cardAt(`${REALM}b`));
+		service.canInvoke("read", cardAt(`${OTHER}c`));
+		await settled();
+		indexed(REALM, [`${REALM}realm`]);
+		await settled();
+		assert.deepEqual(realmUnderTest.sent.slice(2).map((request) => request.checks.map((check) => check.target)), [[`${REALM}a`, `${REALM}b`]], "the config can change the policy every answer in the realm rests on, and another realm’s answers are untouched");
+	});
+	(0, import_qunit.test)("an answer past its age is asked again by the next read of it", async function(assert) {
+		let realNow = Date.now;
+		let now = realNow();
+		Date.now = () => now;
+		try {
+			realmUnderTest.allow.add(`read ${REALM}a`);
+			service.canInvoke("read", cardAt(`${REALM}a`));
+			await settled();
+			assert.true(service.canInvoke("read", cardAt(`${REALM}a`)));
+			await settled();
+			assert.strictEqual(realmUnderTest.sent.length, 1, "a fresh answer is served without asking");
+			realmUnderTest.allow.delete(`read ${REALM}a`);
+			now += 5e3;
+			assert.true(service.canInvoke("read", cardAt(`${REALM}a`)), "a stale answer is still served while it is asked again");
+			await settled();
+			assert.strictEqual(realmUnderTest.sent.length, 2, "and it was asked");
+			assert.false(service.canInvoke("read", cardAt(`${REALM}a`)));
+		} finally {
+			Date.now = realNow;
+		}
+	});
+	(0, import_qunit.test)("a template reads \"not known\", then re-renders with the answer", async function(assert) {
+		realmUnderTest.allow.add(`read ${REALM}granted`);
+		realmUnderTest.hold();
+		let { canInvoke } = service;
+		let granted = `${REALM}granted`;
+		let denied = `${REALM}denied`;
+		let rendering = render(setComponentTemplate(templateFactory({
+			"id": "QmBDjqcN",
+			"block": "[[[10,1],[14,\"data-test-granted\",\"\"],[12],[1,\"\\n  \"],[41,[28,[32,0],[\"read\",[32,1]],null],[[[1,\"yes\"]],[]],[[[1,\"no\"]],[]]],[1,\"\\n\"],[13],[1,\"\\n\"],[10,1],[14,\"data-test-denied\",\"\"],[12],[1,\"\\n  \"],[41,[28,[32,0],[\"read\",[32,2]],null],[[[1,\"yes\"]],[]],[[[1,\"no\"]],[]]],[1,\"\\n\"],[13]],[],[\"if\"]]",
+			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/can-invoke-test.gts",
+			"scope": () => [
+				canInvoke,
+				granted,
+				denied
+			],
+			"isStrictMode": true
+		}), templateOnly()));
+		await waitUntil(() => realmUnderTest.sent.length === 1);
+		assert.dom("[data-test-granted]").hasText("no", "nothing is shown before the realm has answered");
+		realmUnderTest.release();
+		await rendering;
+		assert.dom("[data-test-granted]").hasText("yes", "the answer lands and the template re-reads it");
+		assert.dom("[data-test-denied]").hasText("no");
+		assert.strictEqual(realmUnderTest.sent.length, 1, "both reads in the render went out together");
+	});
+});
+(0, import_qunit.module)("Integration | canInvoke | a type target", function(hooks) {
+	setupRenderingTest(hooks);
+	(0, import_qunit.test)("a class asks whether a card of that type may be created", async function(assert) {
+		let network = getService("network");
+		let sent = [];
+		let real = network.authedFetch;
+		Object.defineProperty(network, "authedFetch", {
+			configurable: true,
+			value: async (url, init) => {
+				if (!url.endsWith("_capabilities")) return await real(url, init);
+				let { checks } = JSON.parse(String(init.body));
+				sent.push({
+					url,
+					checks
+				});
+				return new Response(JSON.stringify({ checks: checks.map((check) => ({
+					...check,
+					allowed: true
+				})) }), { headers: { "content-type": "application/json" } });
+			}
+		});
+		try {
+			let service = getService("capabilities");
+			assert.strictEqual(service.canInvoke("create", CardDef, { realm: REALM }), void 0);
+			await settled();
+			assert.strictEqual(sent.length, 1, "one request");
+			assert.strictEqual(sent[0].url, `${REALM}_capabilities`, "to the realm the card would be created in");
+			let [check] = sent[0].checks;
+			assert.strictEqual(check.operation, "create");
+			assert.strictEqual(typeof check.target === "object" ? check.target.name : void 0, "CardDef", "naming the type by its code ref rather than any card");
+			assert.true(service.canInvoke("create", CardDef, { realm: REALM }));
+		} finally {
+			delete network.authedFetch;
+		}
+	});
+});
+(0, import_qunit.module)("Integration | canInvoke | a card in the operator-mode stack", function(hooks) {
+	const REALM_URL = "http://test-realm/test-gates/";
+	let loader;
+	setupRenderingTest(hooks);
+	setupOperatorModeStateCleanup(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [baseRealm.url, REALM_URL],
+		autostart: true
+	});
+	hooks.beforeEach(async function() {
+		let { CardDef: Base, Component } = await loader.import("@cardstack/base/card-api");
+		class Gate extends Base {
+			static displayName = "Gate";
+			static isolated = class Isolated extends Component {
+				answer(operation) {
+					let answer = this.args.context?.canInvoke?.(operation, this.args.model);
+					return answer === void 0 ? "unknown" : answer ? "yes" : "no";
+				}
+				get read() {
+					return this.answer("read");
+				}
+				get undeclared() {
+					return this.answer("noSuchOperation");
+				}
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "KBepm2ra",
+						"block": "[[[10,1],[15,\"data-test-gate-read\",[30,0,[\"read\"]]],[12],[1,[30,0,[\"read\"]]],[13],[1,\"\\n\"],[10,1],[15,\"data-test-gate-undeclared\",[30,0,[\"undeclared\"]]],[12],[1,\"\\n  \"],[1,[30,0,[\"undeclared\"]]],[1,\"\\n\"],[13]],[],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/can-invoke-test.gts",
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: REALM_URL,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"gate.gts": { Gate },
+				"Gate/one.json": { data: {
+					type: "card",
+					meta: { adoptsFrom: {
+						module: "../gate",
+						name: "Gate"
+					} }
+				} },
+				"realm.json": realmConfigCardJSON({ name: "Gates" })
+			},
+			startMatrix: false
+		});
+		await mockMatrixUtils.start();
+	});
+	(0, import_qunit.test)("a card’s template reads the realm’s answer off its context", async function(assert) {
+		getService("operator-mode-state-service").restore({ stacks: [[{
+			type: "card",
+			id: `${REALM_URL}Gate/one`,
+			format: "isolated"
+		}]] });
+		let noop = () => {};
+		await renderComponent(class TestDriver extends Component {
+			static {
+				setComponentTemplate(templateFactory({
+					"id": "LNZPzPgG",
+					"block": "[[[8,[32,0],null,[[\"@onClose\"],[[32,1]]],null]],[],[]]",
+					"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/integration/can-invoke-test.gts",
+					"scope": () => [OperatorModeContainer, noop],
+					"isStrictMode": true
+				}), this);
+			}
+		});
+		await waitFor("[data-test-gate-read=\"yes\"]");
+		assert.dom("[data-test-gate-read]").hasText("yes", "the realm admits a read of the card");
+		await waitFor("[data-test-gate-undeclared=\"no\"]");
+		assert.dom("[data-test-gate-undeclared]").hasText("no", "and refuses an operation its type does not carry, so the answer is the realm’s");
+	});
+});
+(0, import_qunit.module)("Integration | canInvoke | a signed-out visitor", function(hooks) {
+	const REALM_URL = "http://test-realm/test-site/";
+	const CARD_URL = `${REALM_URL}Note/one`;
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks);
+	hooks.beforeEach(async function() {
+		await setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: REALM_URL,
+			permissions: { "*": ["read"] },
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"Note/one.json": { data: {
+					type: "card",
+					meta: { adoptsFrom: {
+						module: "@cardstack/base/card-api",
+						name: "CardDef"
+					} }
+				} },
+				"realm.json": realmConfigCardJSON({ name: "Site" })
+			}
+		});
+	});
+	(0, import_qunit.test)("a capability check made with no Matrix client is answered as the anonymous caller", async function(assert) {
+		let card = await getService("store").get(CARD_URL);
+		if (!card || isCardErrorJSONAPI(card)) throw new Error(`expected ${CARD_URL} to load, got ${JSON.stringify(card)}`);
+		let realm = getService("realm");
+		realm.removeRealm(REALM_URL);
+		assert.false(getService("realm-server").hasClient, "there is no Matrix client to sign in with");
+		assert.strictEqual(realm.realmOf(rri(CARD_URL)), void 0, "and the realm service does not know the card’s realm");
+		let service = getService("capabilities");
+		assert.strictEqual(service.canInvoke("read", card), void 0, "nothing is known before the realm has been asked");
+		await waitUntil(() => service.canInvoke("read", card) !== void 0);
+		assert.true(service.canInvoke("read", card), "the realm admits an anonymous read, and the card hears it");
+		assert.strictEqual(service.canInvoke("noSuchOperation", card), void 0, "a second pair is enrolled the same way");
+		await waitUntil(() => service.canInvoke("noSuchOperation", card) !== void 0);
+		assert.false(service.canInvoke("noSuchOperation", card), "and an operation the card does not carry is refused, so the answer is the realm’s");
+		realm.removeRealm(REALM_URL);
+		service.resetState();
+		assert.strictEqual(service.canInvoke("read", CARD_URL), void 0, "a URL in a realm that is not known has nothing to answer yet");
+		await waitUntil(() => service.canInvoke("read", CARD_URL) !== void 0);
+		assert.true(service.canInvoke("read", CARD_URL), "once its realm has been looked up, the check is answered as for the card");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/can-read-realm-test-CIz6WX_K.js

@@ -0,0 +1,56 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as CanReadRealmTool } from "./can-read-realm-BxbMu4M5.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-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/can-read-realm-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var readableUrls;
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | can-read-realm", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	setupRealmServerEndpoints(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	hooks.beforeEach(function() {
+		getOwner(this).register("service:realm", StubRealmService);
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		}));
+	});
+	hooks.beforeEach(function() {
+		let realmService = getService("realm");
+		realmService.canRead = (url) => {
+			return readableUrls.includes(url);
+		};
+	});
+	(0, import_qunit.test)("returns true for a readable realm", async function(assert) {
+		readableUrls = ["https://example.com/readable/"];
+		let result = await new CanReadRealmTool(getService("tool-service").toolContext).execute({ realmIdentifier: "https://example.com/readable/" });
+		assert.true(result.canRead);
+	});
+	(0, import_qunit.test)("returns false for an unreadable realm", async function(assert) {
+		readableUrls = [];
+		let result = await new CanReadRealmTool(getService("tool-service").toolContext).execute({ realmIdentifier: "https://example.com/private/" });
+		assert.false(result.canRead);
+	});
+});
+//#endregion

package/bundled-test-harness/assets/cancel-indexing-job-test-0LlrOgYK.js

@@ -0,0 +1,69 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL, Rr as testRealmInfo } from "./runtime-common-BTaLJEw-.js";
+import { t as getOwner } from "./owner-BT6cj890.js";
+import { n as RealmService } from "./realm-C_a9su1j.js";
+import { t as CancelIndexingJobTool } from "./cancel-indexing-job-DVNHUiEd.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-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/integration/tools/cancel-indexing-job-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var StubRealmService = class extends RealmService {
+	get defaultReadableRealm() {
+		return {
+			path: testRealmURL,
+			info: testRealmInfo
+		};
+	}
+};
+(0, import_qunit.module)("Integration | tools | cancel-indexing-job", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let receivedAuthorizationHeader = null;
+	let receivedMethod = null;
+	let receivedPathname = null;
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	setupRealmServerEndpoints(hooks, [{
+		route: "test/_cancel-indexing-job",
+		getResponse: async (req) => {
+			receivedAuthorizationHeader = req.headers.get("Authorization");
+			receivedMethod = req.method;
+			receivedPathname = new URL(req.url).pathname;
+			return new Response(null, { status: 204 });
+		}
+	}]);
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		getOwner(this).register("service:realm", StubRealmService);
+		receivedAuthorizationHeader = null;
+		receivedMethod = null;
+		receivedPathname = null;
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			realmURL: testRealmURL,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("calls realm endpoint with expected auth header", async function(assert) {
+		let toolService = getService("tool-service");
+		let realmServer = getService("realm-server");
+		let command = new CancelIndexingJobTool(toolService.toolContext);
+		let realmURL = new URL("test/", realmServer.url).href;
+		let result = await command.execute({ realmIdentifier: realmURL });
+		assert.strictEqual(result, void 0, "command has no result card");
+		assert.strictEqual(receivedMethod, "POST", "uses POST");
+		assert.strictEqual(receivedPathname, "/test/_cancel-indexing-job", "calls correct endpoint");
+		assert.ok(receivedAuthorizationHeader, "authorization header is present");
+		assert.true(receivedAuthorizationHeader?.startsWith("Bearer "), "authorization header uses Bearer scheme");
+		let [_header, payload] = receivedAuthorizationHeader.replace("Bearer ", "").split(".");
+		let tokenClaims = JSON.parse(atob(payload));
+		assert.strictEqual(tokenClaims.realm, realmURL, "authorization token is realm-scoped");
+		assert.deepEqual(tokenClaims.permissions, ["read", "write"], "authorization token contains realm permissions");
+		assert.notStrictEqual(receivedAuthorizationHeader, `Bearer ${realmServer.token}`, "authorization header does not use realm-server session token");
+	});
+});
+//#endregion