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

package/bundled-test-harness/assets/open-secure-window-test-dz1vPudF.js

@@ -0,0 +1,253 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as config } from "./environment-DIUJgBKt.js";
+import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
+import { H as templateFactory, S as on } from "./index-DaCZcoCY-CgzbilMy.js";
+import { n as src_default } from "./src-DPaAwa4H.js";
+import { n as TrackedObject } from "./dist-B9tGPKZz.js";
+import "./modifier-D0EP-FQ7.js";
+import "./component-BJO47HTh.js";
+import "./template-factory-ds9s0u8l.js";
+import { d as click, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as OpenSecureWindowTool } from "./open-secure-window-w4rvg9oI.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, a as SYSTEM_CARD_FIXTURE_CONTENTS, ct as setupApplicationTest, j as setupAcceptanceTestRealm, st as visitOperatorMode, t as setupMockMatrix } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { u as getFields } from "./field-support-DClsIsjq.js";
+import { a as CardDef, s as Component } from "./card-api-Cc8uZunB.js";
+import { t as stubWindowOpen } from "./window-open-B-LVJ3H0.js";
+//#region tests/acceptance/open-secure-window-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var OPERATION = "forecast";
+var REASON = "Weather Station needs your forecast service key";
+(0, import_qunit.module)("Acceptance | open the secure window", function(hooks) {
+	setupApplicationTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL]
+	});
+	let secureOrigin = new URL(config.secureOriginURL);
+	hooks.beforeEach(async function() {
+		class WeatherStation extends CardDef {
+			static displayName = "Weather Station";
+			static isolated = class Isolated extends Component {
+				result = new TrackedObject({ status: "" });
+				open = async (mode) => {
+					let result = await new OpenSecureWindowTool(this.args.context.toolContext).execute(mode !== "share-key" ? {
+						mode,
+						cardId: this.args.model.id,
+						operation: OPERATION,
+						reason: REASON
+					} : {
+						mode,
+						realm: testRealmURL,
+						reason: REASON
+					});
+					this.result.status = result.status ?? "";
+				};
+				enterKey = () => this.open("enter-key");
+				shareKey = () => this.open("share-key");
+				reconnect = () => this.open("replace-key");
+				static {
+					setComponentTemplate(templateFactory({
+						"id": "+q+I7Wqr",
+						"block": "[[[11,\"button\"],[24,\"data-test-enter-key\",\"\"],[4,[32,0],[\"click\",[30,0,[\"enterKey\"]]],null],[12],[1,\"\\n  Enter key\\n\"],[13],[1,\"\\n\"],[11,\"button\"],[24,\"data-test-share-key\",\"\"],[4,[32,0],[\"click\",[30,0,[\"shareKey\"]]],null],[12],[1,\"\\n  Share key\\n\"],[13],[1,\"\\n\"],[11,\"button\"],[24,\"data-test-reconnect\",\"\"],[4,[32,0],[\"click\",[30,0,[\"reconnect\"]]],null],[12],[1,\"\\n  Reconnect\\n\"],[13],[1,\"\\n\"],[10,1],[14,\"data-test-status\",\"\"],[12],[1,[30,0,[\"result\",\"status\"]]],[13]],[],[]]",
+						"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/acceptance/open-secure-window-test.gts",
+						"scope": () => [on],
+						"isStrictMode": true
+					}), this);
+				}
+			};
+		}
+		await setupAcceptanceTestRealm({
+			mockMatrixUtils,
+			contents: {
+				...SYSTEM_CARD_FIXTURE_CONTENTS,
+				"weather-station.gts": { WeatherStation },
+				"WeatherStation/home.json": { data: {
+					attributes: {},
+					meta: { adoptsFrom: {
+						module: "../weather-station",
+						name: "WeatherStation"
+					} }
+				} }
+			}
+		});
+	});
+	async function visitWeatherStation() {
+		await visitOperatorMode({ stacks: [[{
+			id: `${testRealmURL}WeatherStation/home`,
+			format: "isolated"
+		}]] });
+		await waitFor("[data-test-enter-key]");
+	}
+	(0, import_qunit.test)("a card opens the window to enter a key for its operation", async function(assert) {
+		let { calls, popups } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		await click("[data-test-enter-key]");
+		await waitFor("[data-test-status]:not(:empty)");
+		assert.strictEqual(calls.length, 1, "one window opened");
+		let [{ url, target, features }] = calls;
+		let opened = new URL(url);
+		assert.strictEqual(opened.origin, secureOrigin.origin, "on the secure origin");
+		assert.strictEqual(opened.pathname, `${secureOrigin.pathname.replace(/\/+$/, "")}/enter-key`, "at the enter-key page");
+		assert.strictEqual(opened.search, "", "nothing in the query string");
+		let fragment = new URLSearchParams(opened.hash.slice(1));
+		assert.deepEqual([...fragment.keys()], [
+			"card",
+			"operation",
+			"reason"
+		], "the fragment names the card, the operation and the reason, and nothing else");
+		assert.strictEqual(fragment.get("card"), `${testRealmURL}WeatherStation/home`);
+		assert.strictEqual(fragment.get("operation"), OPERATION);
+		assert.strictEqual(fragment.get("reason"), REASON);
+		assert.notOk(/ticket|session|token|jwt/i.test(url), "the address carries no ticket, session or token");
+		assert.strictEqual(target, "_blank");
+		assert.strictEqual(features, "popup,width=800,height=1000");
+		assert.strictEqual(popups[0].opener, null, "the opener is cut");
+		assert.dom("[data-test-status]").hasText("opened");
+		assert.dom("[data-test-secure-window-fallback]").doesNotExist();
+	});
+	(0, import_qunit.test)("a card opens the window to share a key into a realm", async function(assert) {
+		let { calls } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		await click("[data-test-share-key]");
+		await waitFor("[data-test-status]:not(:empty)");
+		assert.strictEqual(calls.length, 1);
+		let opened = new URL(calls[0].url);
+		assert.true(opened.pathname.endsWith("/share-key"), "at the share-key page");
+		assert.strictEqual(opened.search, "");
+		let fragment = new URLSearchParams(opened.hash.slice(1));
+		assert.deepEqual([...fragment.keys()], ["realm", "reason"]);
+		assert.strictEqual(fragment.get("realm"), testRealmURL);
+		assert.dom("[data-test-status]").hasText("opened");
+	});
+	(0, import_qunit.test)("a card’s Reconnect opens the window to replace the key its operation sends", async function(assert) {
+		let { calls, popups } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		await click("[data-test-reconnect]");
+		await waitFor("[data-test-status]:not(:empty)");
+		assert.strictEqual(calls.length, 1, "one window opened");
+		let opened = new URL(calls[0].url);
+		assert.strictEqual(opened.origin, secureOrigin.origin);
+		assert.strictEqual(opened.pathname, `${secureOrigin.pathname.replace(/\/+$/, "")}/replace-key`, "at the replace-key page");
+		assert.strictEqual(opened.search, "", "nothing in the query string");
+		let fragment = new URLSearchParams(opened.hash.slice(1));
+		assert.deepEqual(Object.fromEntries(fragment), {
+			card: `${testRealmURL}WeatherStation/home`,
+			operation: OPERATION,
+			reason: REASON
+		}, "the card and operation name the key; the card never names one itself");
+		assert.strictEqual(popups[0].opener, null, "the opener is cut");
+		assert.dom("[data-test-status]").hasText("opened");
+	});
+	(0, import_qunit.test)("a blocked popup shows a button that opens the window", async function(assert) {
+		let stub = stubWindowOpen(src_default);
+		stub.state.blocked = true;
+		await visitWeatherStation();
+		await click("[data-test-enter-key]");
+		await waitFor("[data-test-secure-window-fallback]");
+		assert.dom("[data-test-status]").hasText("blocked");
+		assert.dom("[data-test-secure-window-fallback]").doesNotContainText(REASON, "the fallback shows nothing the caller wrote, since any card can raise it");
+		assert.dom("[data-test-secure-window-fallback-host]").hasText(secureOrigin.host, "the fallback names the address to check");
+		stub.state.blocked = false;
+		await click("[data-test-secure-window-fallback-open]");
+		assert.strictEqual(stub.calls.length, 2, "the button opens the window");
+		assert.strictEqual(stub.calls[1].url, stub.calls[0].url, "at the address the card asked for");
+		assert.strictEqual(stub.calls[1].features, "popup,width=800,height=1000");
+		assert.strictEqual(stub.popups[0].opener, null, "the opener is cut");
+		assert.dom("[data-test-secure-window-fallback]").doesNotExist();
+	});
+	(0, import_qunit.test)("the fallback can be dismissed without opening the window", async function(assert) {
+		let stub = stubWindowOpen(src_default);
+		stub.state.blocked = true;
+		await visitWeatherStation();
+		await click("[data-test-enter-key]");
+		await waitFor("[data-test-secure-window-fallback]");
+		await click("[data-test-secure-window-fallback-cancel]");
+		assert.dom("[data-test-secure-window-fallback]").doesNotExist();
+		assert.strictEqual(stub.calls.length, 1, "nothing more was opened");
+	});
+	(0, import_qunit.test)("a key for an operation on a card type names the module, export and realm", async function(assert) {
+		let { calls } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		let { toolContext } = getService("tool-service");
+		let result = await new OpenSecureWindowTool(toolContext).execute({
+			mode: "enter-key",
+			module: `${testRealmURL}weather-station`,
+			name: "WeatherStation",
+			realm: testRealmURL,
+			operation: OPERATION
+		});
+		assert.strictEqual(result.status, "opened");
+		let plainFields = Object.keys(getFields(new CardDef()));
+		assert.deepEqual(Object.keys(getFields(result)).filter((f) => !plainFields.includes(f)), ["status"], "the result holds only whether the window opened");
+		let fragment = new URLSearchParams(new URL(calls[0].url).hash.slice(1));
+		assert.deepEqual(Object.fromEntries(fragment), {
+			module: `${testRealmURL}weather-station`,
+			name: "WeatherStation",
+			realm: testRealmURL,
+			operation: OPERATION
+		});
+	});
+	(0, import_qunit.test)("approving opens the window for the one operation a card is blocked on", async function(assert) {
+		let { calls } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		let { toolContext } = getService("tool-service");
+		let tool = new OpenSecureWindowTool(toolContext);
+		for (let mode of ["approve", "review-changes"]) await tool.execute({
+			mode,
+			cardId: `${testRealmURL}WeatherStation/home`,
+			operation: OPERATION
+		});
+		assert.deepEqual(calls.map(({ url }) => new URL(url).pathname.split("/").pop()), ["approve", "review-changes"]);
+		for (let { url } of calls) {
+			let opened = new URL(url);
+			assert.strictEqual(opened.search, "");
+			assert.deepEqual(Object.fromEntries(new URLSearchParams(opened.hash.slice(1))), {
+				card: `${testRealmURL}WeatherStation/home`,
+				operation: OPERATION
+			}, "the card and its one operation, never the others it has");
+		}
+		await assert.rejects(tool.execute({
+			mode: "approve",
+			cardId: `${testRealmURL}WeatherStation/home`
+		}), /an approval names the operation/, "an approval names the operation it is blocked on");
+	});
+	(0, import_qunit.test)("what the window is opened for must name things it can read", async function(assert) {
+		let { calls } = stubWindowOpen(src_default);
+		await visitWeatherStation();
+		let { toolContext } = getService("tool-service");
+		let tool = new OpenSecureWindowTool(toolContext);
+		await assert.rejects(tool.execute({
+			mode: "delete-key",
+			realm: testRealmURL
+		}), /mode must be one of "enter-key", "replace-key", "share-key", "swap-key", "share-limits", "connect", "approve", "review-changes"/, "an unsupported mode");
+		await assert.rejects(tool.execute({
+			mode: "swap-key",
+			realm: testRealmURL
+		}), /share is required/, "a swap with no share");
+		await assert.rejects(tool.execute({
+			mode: "share-limits",
+			realm: testRealmURL
+		}), /share is required/, "a share’s limits with no share");
+		await assert.rejects(tool.execute({ mode: "share-key" }), /realm is required/, "a share with no realm");
+		await assert.rejects(tool.execute({
+			mode: "enter-key",
+			cardId: "javascript:alert(1)",
+			operation: OPERATION
+		}), /cardId must be a URL or a prefix-form id/, "a card that is not a URL");
+		await assert.rejects(tool.execute({
+			mode: "enter-key",
+			operation: OPERATION
+		}), /an operation needs the card/, "an operation with nothing it is on");
+		await assert.rejects(tool.execute({
+			mode: "replace-key",
+			cardId: `${testRealmURL}WeatherStation/home`
+		}), /replace-key is for an operation/, "a replace with no operation, whose key the window could not find");
+		await assert.rejects(tool.execute({ mode: "replace-key" }), /replace-key is for an operation/, "a replace with nothing it is for");
+		assert.strictEqual(calls.length, 0, "no window opened");
+	});
+});
+//#endregion

package/bundled-test-harness/assets/open-workspace-test-BvTcskzP.js

@@ -0,0 +1,46 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
+import { t as OpenWorkspaceTool } from "./open-workspace-Btaleksy.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, L as setupRealmCacheTeardown, P as setupIntegrationTestRealm, 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/open-workspace-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+(0, import_qunit.module)("Integration | tools | open-workspace", function(hooks) {
+	setupRenderingTest(hooks);
+	setupLocalIndexing(hooks);
+	let mockMatrixUtils = setupMockMatrix(hooks, {
+		loggedInAs: "@testuser:localhost",
+		activeRealms: [testRealmURL],
+		autostart: true
+	});
+	setupRealmCacheTeardown(hooks);
+	hooks.beforeEach(async function() {
+		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
+			mockMatrixUtils,
+			contents: {}
+		}));
+	});
+	(0, import_qunit.test)("opens specified workspace in interact submode", async function(assert) {
+		let toolService = getService("tool-service");
+		let operatorModeStateService = getService("operator-mode-state-service");
+		operatorModeStateService.restore({
+			stacks: [],
+			submode: "interact",
+			workspaceChooserOpened: true
+		});
+		let openWorkspaceCommand = new OpenWorkspaceTool(toolService.toolContext);
+		assert.strictEqual(operatorModeStateService.state?.submode, "interact");
+		await openWorkspaceCommand.execute({ realmIdentifier: testRealmURL });
+		assert.strictEqual(operatorModeStateService.state?.submode, "interact");
+		assert.strictEqual(operatorModeStateService.state?.stacks.length, 1);
+		assert.strictEqual(operatorModeStateService.state?.stacks[0].length, 1);
+		assert.strictEqual(operatorModeStateService.state?.stacks[0][0].id, `${testRealmURL}index`);
+		assert.strictEqual(operatorModeStateService.state?.stacks[0][0].format, "isolated");
+		let realmUrlWithTrailingSlash = testRealmURL;
+		let realmUrlWithoutTrailingSlash = testRealmURL.replace(/\/$/, "");
+		await openWorkspaceCommand.execute({ realmIdentifier: realmUrlWithoutTrailingSlash });
+		assert.strictEqual(operatorModeStateService.state?.stacks[0][0].id, `${realmUrlWithTrailingSlash}index`);
+	});
+});
+//#endregion