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

package/bundled-test-harness/assets/dashboard-workspace-test-DqBdCFo2.js

@@ -0,0 +1,537 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { Rr as testRealmInfo, Xn as APP_BOXEL_REALM_EVENT_TYPE } from "./runtime-common-BTaLJEw-.js";
+import { w as ri } from "./paths-C9-NYXnM.js";
+import { n as TrackedObject } from "./dist-B9tGPKZz.js";
+import { T as settled, a as find, c as triggerKeyEvent, d as click, f as focus, i as findAll, l as triggerEvent, o as waitFor } from "./dist-BOAdzfkP.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { D as realmConfigCardJSON, ht as setupPublicReadableRealms, j as setupAcceptanceTestRealm, st as visitOperatorMode } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+import { m as setupDashboardTest, s as operatorModeState, u as pressKey } from "./dashboard-ir2bakJS.js";
+import { t as suspendGlobalErrorHook } from "./uncaught-exceptions-Cm9iqRb6.js";
+//#region tests/acceptance/dashboard-workspace-test.gts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var realmAURL = "http://test-realm/testuser/workspace-a/";
+var realmBURL = "http://test-realm/testuser/workspace-b/";
+var cardsGridIndex = { data: {
+	type: "card",
+	meta: { adoptsFrom: {
+		module: "@cardstack/base/cards-grid",
+		name: "CardsGrid"
+	} }
+} };
+var realmA;
+function withUpdatedRealmInfo(realmURL, updates) {
+	let realmResource = getService("realm").realms.get(realmURL);
+	if (!realmResource) throw new Error(`Realm resource for ${realmURL} is not registered`);
+	let previousInfo = realmResource.info;
+	realmResource.info = new TrackedObject({
+		...previousInfo ? { ...previousInfo } : { ...testRealmInfo },
+		...updates
+	});
+	return () => {
+		realmResource.info = previousInfo;
+	};
+}
+function withIndexCounts(realmURL, counts) {
+	getService("realm").indexCountsByRealm.set(realmURL, counts);
+}
+(0, import_qunit.module)("Acceptance | dashboard workspace", function(hooks) {
+	let mockMatrixUtils = setupDashboardTest(hooks, {
+		matrix: {
+			loggedInAs: "@testuser:localhost",
+			activeRealms: [realmAURL, realmBURL]
+		},
+		realms: [{
+			url: realmAURL,
+			name: "Workspace A",
+			contents: { "index.json": cardsGridIndex }
+		}, {
+			url: realmBURL,
+			name: "Workspace B",
+			contents: { "index.json": cardsGridIndex }
+		}],
+		onRealm(realm, url) {
+			if (url === realmAURL) realmA = realm;
+		}
+	});
+	(0, import_qunit.test)("Favorite in the options menu adds the workspace to Favorites", async function(assert) {
+		await visitOperatorMode({ workspaceChooserOpened: true });
+		assert.dom("[data-test-dashboard]").exists();
+		await click(`[data-test-workspace-menu-trigger="${realmAURL}"]`);
+		await click("[data-test-boxel-menu-item-text=\"Favorite\"]");
+		assert.dom("[data-test-favorites-list] [data-test-workspace=\"Workspace A\"]").exists("the workspace shows in Favorites");
+		assert.deepEqual(getService("matrix-service").workspaceFavorites, [realmAURL], "the favorite is saved");
+	});
+	(0, import_qunit.module)("desk counts", function() {
+		async function openDashboardWithFavorite() {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let matrixService = getService("matrix-service");
+			matrixService.workspaceFavorites = [realmAURL];
+			await settled();
+			await waitFor("[data-test-favorites-list] [data-test-workspace]");
+		}
+		const STATS = `[data-test-favorites-list] [data-test-workspace-stats="${realmAURL}"]`;
+		function deskStat(label) {
+			return `${STATS} [data-test-workspace-stat="${label}"]`;
+		}
+		(0, import_qunit.test)("a desk shows its Cards, Files and Definitions counts", async function(assert) {
+			await openDashboardWithFavorite();
+			withIndexCounts(realmAURL, {
+				cardCount: 12,
+				fileCount: 34,
+				definitionCount: 5
+			});
+			await settled();
+			assert.dom(deskStat("Cards")).hasText("Cards 12");
+			assert.dom(deskStat("Files")).hasText("Files 34");
+			assert.dom(deskStat("Definitions")).hasText("Definitions 5");
+			assert.dom(`${STATS} [data-test-workspace-stat]`).exists({ count: 3 }, "all three counts show, and no pin count");
+		});
+		(0, import_qunit.test)("a desk leaves out a count of zero or one that is unknown", async function(assert) {
+			await openDashboardWithFavorite();
+			withIndexCounts(realmAURL, {
+				cardCount: 7,
+				fileCount: 0,
+				definitionCount: null
+			});
+			await settled();
+			assert.dom(deskStat("Cards")).hasText("Cards 7");
+			assert.dom(deskStat("Files")).doesNotExist("a zero count is left out, not shown as \"Files 0\"");
+			assert.dom(deskStat("Definitions")).doesNotExist("an unknown count is left out");
+		});
+		(0, import_qunit.test)("a desk's counts fill space kept for them, without changing its height", async function(assert) {
+			await openDashboardWithFavorite();
+			assert.dom(STATS).exists("the counts line is there before they load");
+			assert.dom(`${STATS} [data-test-workspace-stat]`).doesNotExist("but shows no counts yet");
+			let heightBefore = find(STATS).getBoundingClientRect().height;
+			assert.ok(heightBefore > 0, `the empty line still keeps its height, got ${heightBefore}px`);
+			withIndexCounts(realmAURL, {
+				cardCount: 12,
+				fileCount: 34,
+				definitionCount: 5
+			});
+			await settled();
+			let heightAfter = find(STATS).getBoundingClientRect().height;
+			assert.strictEqual(heightAfter, heightBefore, `the line does not grow when the counts arrive (${heightBefore}px -> ${heightAfter}px)`);
+		});
+		(0, import_qunit.test)("a desk's counts refresh after the realm re-indexes, without blanking first", async function(assert) {
+			await openDashboardWithFavorite();
+			withIndexCounts(realmAURL, {
+				cardCount: 12,
+				fileCount: 34,
+				definitionCount: 5
+			});
+			await settled();
+			assert.dom(deskStat("Cards")).hasText("Cards 12");
+			let realmService = getService("realm");
+			let requestedRealms = [];
+			let realmServerService = getService("realm-server");
+			let originalFetch = realmServerService.fetchRealmIndexCounts;
+			realmServerService.fetchRealmIndexCounts = async (urls) => {
+				requestedRealms.push(urls);
+				return [{
+					id: realmAURL,
+					attributes: {
+						cardCount: 13,
+						fileCount: 34,
+						definitionCount: 5
+					}
+				}];
+			};
+			try {
+				realmService.markIndexCountsStale(realmAURL);
+				await settled();
+				assert.deepEqual(requestedRealms, [[realmAURL]], "the stale realm is requested again exactly once");
+				assert.dom(deskStat("Cards")).hasText("Cards 13", "the desk shows the refreshed count");
+			} finally {
+				realmServerService.fetchRealmIndexCounts = originalFetch;
+			}
+		});
+		(0, import_qunit.test)("a desk keeps its previous counts while they are fetched again", async function(assert) {
+			await openDashboardWithFavorite();
+			withIndexCounts(realmAURL, {
+				cardCount: 12,
+				fileCount: 34,
+				definitionCount: 5
+			});
+			await settled();
+			let realmServerService = getService("realm-server");
+			let originalFetch = realmServerService.fetchRealmIndexCounts;
+			let fetches = 0;
+			realmServerService.fetchRealmIndexCounts = () => {
+				fetches++;
+				return new Promise(() => {});
+			};
+			try {
+				getService("realm").markIndexCountsStale(realmAURL);
+				await settled();
+				assert.strictEqual(fetches, 1, "the counts are being fetched again");
+				assert.dom(deskStat("Cards")).hasText("Cards 12", "the previous counts stay while fetching");
+			} finally {
+				realmServerService.fetchRealmIndexCounts = originalFetch;
+			}
+		});
+		(0, import_qunit.test)("only desks show counts", async function(assert) {
+			await openDashboardWithFavorite();
+			withIndexCounts(realmAURL, {
+				cardCount: 12,
+				fileCount: 34,
+				definitionCount: 5
+			});
+			await settled();
+			assert.dom(`[data-test-workspace-list] [data-test-workspace-stats="${realmAURL}"]`).doesNotExist("the Your Workspaces tile shows no counts");
+		});
+	});
+	(0, import_qunit.module)("catalog order", function(hooks) {
+		const catalogOneURL = "http://test-realm/catalogs/one/";
+		const catalogTwoURL = "http://test-realm/catalogs/two/";
+		hooks.beforeEach(async function() {
+			for (let [realmURL, name] of [[catalogOneURL, "Catalog One"], [catalogTwoURL, "Catalog Two"]]) await setupAcceptanceTestRealm({
+				realmURL,
+				mockMatrixUtils,
+				permissions: { "*": ["read"] },
+				contents: {
+					"realm.json": realmConfigCardJSON({ name }),
+					"index.json": cardsGridIndex
+				}
+			});
+		});
+		async function showAsCatalogs() {
+			let realmServer = getService("realm-server");
+			for (let url of [catalogOneURL, catalogTwoURL]) if (!realmServer.availableRealms.find((r) => r.url === url)) realmServer.availableRealms.push({
+				type: "catalog",
+				url
+			});
+			await settled();
+			await waitFor("[data-test-catalog-list] [data-test-workspace]");
+		}
+		function orderOfOurCatalogs() {
+			return findAll("[data-test-catalog-list] [data-test-workspace]").map((el) => el.getAttribute("data-test-workspace") ?? "").filter((name) => name === "Catalog One" || name === "Catalog Two");
+		}
+		(0, import_qunit.test)("catalogs are ordered newest created first", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			await showAsCatalogs();
+			let restoreOne = withUpdatedRealmInfo(catalogOneURL, { createdAt: "2024-01-01T00:00:00.000Z" });
+			let restoreTwo = withUpdatedRealmInfo(catalogTwoURL, { createdAt: "2026-01-01T00:00:00.000Z" });
+			await settled();
+			assert.deepEqual(orderOfOurCatalogs(), ["Catalog Two", "Catalog One"], "the more recently created catalog comes first");
+			restoreTwo();
+			restoreOne();
+			restoreOne = withUpdatedRealmInfo(catalogOneURL, { createdAt: "2026-06-01T00:00:00.000Z" });
+			restoreTwo = withUpdatedRealmInfo(catalogTwoURL, { createdAt: "2024-06-01T00:00:00.000Z" });
+			await settled();
+			assert.deepEqual(orderOfOurCatalogs(), ["Catalog One", "Catalog Two"], "swapping the creation dates swaps the order");
+			restoreTwo();
+			restoreOne();
+		});
+		(0, import_qunit.test)("a catalog with no creation date comes after the dated ones", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			await showAsCatalogs();
+			let restoreOne = withUpdatedRealmInfo(catalogOneURL, { createdAt: null });
+			let restoreTwo = withUpdatedRealmInfo(catalogTwoURL, { createdAt: "2024-01-01T00:00:00.000Z" });
+			await settled();
+			assert.deepEqual(orderOfOurCatalogs(), ["Catalog Two", "Catalog One"], "a realm with no creation date comes after a dated one");
+			restoreTwo();
+			restoreOne();
+		});
+	});
+	(0, import_qunit.module)("choosing catalogs", function(hooks) {
+		const publicGalleryURL = "http://test-realm/someone-else/public-gallery/";
+		const GALLERY_CATALOG = "[data-test-catalog-list] [data-test-workspace=\"Public Gallery\"]";
+		hooks.beforeEach(async function() {
+			await setupAcceptanceTestRealm({
+				realmURL: publicGalleryURL,
+				mockMatrixUtils,
+				permissions: { "*": ["read"] },
+				contents: {
+					"realm.json": realmConfigCardJSON({ name: "Public Gallery" }),
+					"index.json": cardsGridIndex
+				}
+			});
+			setupPublicReadableRealms([{
+				url: publicGalleryURL,
+				name: "Public Gallery"
+			}, {
+				url: realmAURL,
+				name: "Workspace A"
+			}]);
+		});
+		function realmCheckbox(url) {
+			return `[data-test-pretui-list-row]:has([data-test-public-realm="${url}"]) [data-test-pretui-list-select]`;
+		}
+		async function storedCatalogRealms() {
+			return (await getService("matrix-service").client.getAccountDataFromServer("app.boxel.catalog-realms"))?.realms ?? [];
+		}
+		(0, import_qunit.test)("a public realm can be added to Catalogs", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			assert.dom(GALLERY_CATALOG).doesNotExist("the public realm is not a catalog to begin with");
+			await click("[data-test-manage-catalogs]");
+			await waitFor(`[data-test-public-realm="${publicGalleryURL}"]`);
+			assert.dom(`[data-test-public-realm="${realmAURL}"]`).doesNotExist("a realm of the user's own is not offered");
+			assert.dom(realmCheckbox(publicGalleryURL)).isNotChecked();
+			await click(realmCheckbox(publicGalleryURL));
+			assert.dom(realmCheckbox(publicGalleryURL)).isChecked();
+			await click("[data-test-save-manage-catalogs]");
+			assert.dom("[data-test-manage-catalogs-error]").doesNotExist();
+			assert.dom("[data-test-manage-catalogs-modal]").doesNotExist();
+			await waitFor(GALLERY_CATALOG);
+			assert.dom(GALLERY_CATALOG).exists("the chosen realm shows in Catalogs");
+			assert.deepEqual(await storedCatalogRealms(), [publicGalleryURL], "the choice is saved to the account data");
+		});
+		(0, import_qunit.test)("a public realm the user added can be taken out of Catalogs", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			await getService("matrix-service").setUserCatalogRealms([publicGalleryURL]);
+			await waitFor(GALLERY_CATALOG);
+			await click("[data-test-manage-catalogs]");
+			await waitFor(`[data-test-public-realm="${publicGalleryURL}"]`);
+			assert.dom(realmCheckbox(publicGalleryURL)).isChecked("the realm the user added is checked");
+			await click(`[data-test-public-realm="${publicGalleryURL}"]`);
+			assert.dom(realmCheckbox(publicGalleryURL)).isNotChecked();
+			await click("[data-test-save-manage-catalogs]");
+			assert.dom(GALLERY_CATALOG).doesNotExist("the realm is gone from Catalogs");
+			assert.deepEqual(await storedCatalogRealms(), []);
+			let realmServer = getService("realm-server");
+			assert.deepEqual(realmServer.userCatalogRealmIdentifiers, []);
+		});
+		(0, import_qunit.test)("canceling the catalog picker changes nothing", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			await click("[data-test-manage-catalogs]");
+			await waitFor(`[data-test-public-realm="${publicGalleryURL}"]`);
+			await click(realmCheckbox(publicGalleryURL));
+			await click("[data-test-cancel-manage-catalogs]");
+			assert.dom("[data-test-manage-catalogs-modal]").doesNotExist();
+			assert.dom(GALLERY_CATALOG).doesNotExist();
+			assert.deepEqual(await storedCatalogRealms(), []);
+		});
+		(0, import_qunit.test)("a pick another list shows survives a save and comes back when that list stops showing it", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let matrixService = getService("matrix-service");
+			let realmServer = getService("realm-server");
+			await matrixService.setUserCatalogRealms([publicGalleryURL]);
+			let ownRealms = realmServer.userRealmIdentifiers;
+			await realmServer.setAvailableRealmIdentifiers([...ownRealms, ri(publicGalleryURL)]);
+			await settled();
+			assert.dom(GALLERY_CATALOG).doesNotExist("the realm is listed with the user’s own realms");
+			await click("[data-test-manage-catalogs]");
+			await waitFor("[data-test-public-realm-list]");
+			assert.dom(`[data-test-public-realm="${publicGalleryURL}"]`).doesNotExist("the picker does not offer it");
+			await click("[data-test-save-manage-catalogs]");
+			assert.deepEqual(await storedCatalogRealms(), [publicGalleryURL], "saving keeps the pick");
+			await realmServer.setAvailableRealmIdentifiers(ownRealms);
+			await waitFor(GALLERY_CATALOG);
+			assert.dom(GALLERY_CATALOG).exists("the pick is back in Catalogs");
+		});
+		(0, import_qunit.test)("a favorited public realm that no list shows becomes a catalog pick", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let matrixService = getService("matrix-service");
+			matrixService.workspaceFavorites = [publicGalleryURL, "http://test-realm/someone-else/private/"];
+			await matrixService.adoptUnlistedFavoritesAsCatalogs();
+			assert.deepEqual(await storedCatalogRealms(), [publicGalleryURL], "only the public realm is added to the picks");
+			await waitFor("[data-test-favorites-list] [data-test-workspace=\"Public Gallery\"]");
+			assert.dom(GALLERY_CATALOG).exists("the realm shows in Catalogs");
+			assert.dom("[data-test-favorites-list] [data-test-workspace=\"Public Gallery\"]").exists("and stays among the favorites");
+		});
+		(0, import_qunit.test)("an empty Catalogs section points at the gear", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let realmServer = getService("realm-server");
+			for (let i = realmServer.availableRealms.length - 1; i >= 0; i--) if (realmServer.availableRealms[i].type === "catalog") realmServer.availableRealms.splice(i, 1);
+			await settled();
+			assert.dom("[data-test-catalog-empty]").hasText("No catalogs yet. Add public realms with the gear.");
+			assert.dom("[data-test-manage-catalogs]").exists();
+		});
+	});
+	(0, import_qunit.module)("options menu footer", function() {
+		(0, import_qunit.test)("shows when the workspace was updated and created, relative to now", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let restore = withUpdatedRealmInfo(realmAURL, {
+				createdAt: (/* @__PURE__ */ new Date(Date.now() - 10800 * 1e3)).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date(Date.now() - 300 * 1e3)).toISOString()
+			});
+			try {
+				await settled();
+				await click(`[data-test-workspace-menu-trigger="${realmAURL}"]`);
+				assert.dom(`[data-test-workspace-menu-footer="${realmAURL}"]`).includesText("Updated 5 min ago").includesText("Created").includesText("3 hrs ago");
+			} finally {
+				restore();
+			}
+		});
+		(0, import_qunit.test)("is left out when neither time is known", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let restore = withUpdatedRealmInfo(realmAURL, {
+				createdAt: null,
+				updatedAt: null
+			});
+			try {
+				await settled();
+				await click(`[data-test-workspace-menu-trigger="${realmAURL}"]`);
+				assert.dom("[data-test-boxel-menu-item-text=\"Realm Settings\"]").exists("the menu itself is open");
+				assert.dom(`[data-test-workspace-menu-footer="${realmAURL}"]`).doesNotExist("no footer without a time to show");
+			} finally {
+				restore();
+			}
+		});
+	});
+	(0, import_qunit.module)("realm rename", function() {
+		(0, import_qunit.test)("a workspace's new name shows after its re-index, without a reload", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"] [data-test-workspace-name]").hasText("Workspace A", "the workspace shows its original name");
+			await realmA.write("realm.json", realmConfigCardJSON({ name: "Renamed Workspace A" }));
+			await settled();
+			assert.dom("[data-test-workspace-list] [data-test-workspace=\"Renamed Workspace A\"] [data-test-workspace-name]").hasText("Renamed Workspace A", "the new name shows");
+			assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"]").doesNotExist("the old name is gone");
+		});
+		(0, import_qunit.test)("re-indexing an unrelated card keeps the workspace's publish state", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"] [data-test-workspace-name]").hasText("Workspace A");
+			let realmService = getService("realm");
+			let resource = realmService.realms.get(realmAURL);
+			resource.info.lastPublishedAt = { "https://example.com/published/": "123" };
+			mockMatrixUtils.simulateRemoteMessage(mockMatrixUtils.getRoomIdForRealmAndUser(realmAURL, "@testuser:localhost"), testRealmInfo.realmUserId, {
+				eventName: "index",
+				indexType: "incremental",
+				invalidations: [`${realmAURL}index`],
+				realmURL: realmAURL
+			}, { type: APP_BOXEL_REALM_EVENT_TYPE });
+			await settled();
+			assert.deepEqual(realmService.info(realmAURL).lastPublishedAt, { "https://example.com/published/": "123" }, "the publish state is kept");
+			assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"] [data-test-workspace-name]").hasText("Workspace A", "the name is unchanged");
+		});
+	});
+	(0, import_qunit.module)("realms with the same name", function() {
+		async function hoverForRealmURL(section, realmURL) {
+			let trigger = `${section} [data-test-realm-url-tooltip-trigger="${realmURL}"]`;
+			await triggerEvent(trigger, "mouseenter");
+			let text = find("[data-test-realm-url-tooltip]")?.textContent?.trim();
+			await triggerEvent(trigger, "mouseleave");
+			return text;
+		}
+		(0, import_qunit.test)("hovering a workspace icon shows its realm URL, so same-named workspaces can be told apart", async function(assert) {
+			let restoreB = withUpdatedRealmInfo(realmBURL, { name: "Workspace A" });
+			try {
+				await visitOperatorMode({ workspaceChooserOpened: true });
+				assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"]").exists({ count: 2 });
+				assert.strictEqual(await hoverForRealmURL("[data-test-workspace-list]", realmAURL), "test-realm/testuser/workspace-a");
+				assert.strictEqual(await hoverForRealmURL("[data-test-workspace-list]", realmBURL), "test-realm/testuser/workspace-b");
+				let matrixService = getService("matrix-service");
+				matrixService.workspaceFavorites = [realmAURL, realmBURL];
+				await settled();
+				await waitFor("[data-test-favorites-list] [data-test-workspace]");
+				assert.strictEqual(await hoverForRealmURL("[data-test-favorites-list]", realmBURL), "test-realm/testuser/workspace-b");
+			} finally {
+				restoreB();
+			}
+		});
+		(0, import_qunit.test)("a tile's button is named by its workspace, with the realm URL kept out of the name", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let button = find("[data-test-workspace-list] [data-test-workspace-button=\"Workspace B\"]");
+			assert.ok(button, "the tile button renders");
+			assert.notOk(button.textContent?.includes("test-realm/testuser/workspace-b"), "the realm URL is not part of the button");
+			assert.dom("[role=\"img\"]", button).hasAttribute("aria-label", "Workspace B");
+		});
+		(0, import_qunit.test)("the delete and archive confirmations show the realm URL", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			await click(`[data-test-workspace-menu-trigger="${realmBURL}"]`);
+			await click("[data-test-boxel-menu-item-text=\"Delete Workspace\"]");
+			await waitFor(`[data-test-delete-modal="${realmBURL}"]`);
+			assert.dom("[data-test-delete-modal-workspace-url]").hasText("test-realm/testuser/workspace-b");
+			await click("[data-test-cancel-delete-button]");
+			await click(`[data-test-workspace-menu-trigger="${realmBURL}"]`);
+			await click("[data-test-boxel-menu-item-text=\"Archive Workspace\"]");
+			await waitFor("[data-test-archive-modal-workspace-url]");
+			assert.dom("[data-test-archive-modal-workspace-url]").hasText("test-realm/testuser/workspace-b");
+		});
+	});
+	(0, import_qunit.module)("long realm names", function() {
+		const longName = "A Workspace Name Long Enough To Run Well Past The Width Of Any Tile Or Desk";
+		function widthOf(selector) {
+			let el = find(selector);
+			if (!el) throw new Error(`nothing at ${selector}`);
+			return el.getBoundingClientRect().width;
+		}
+		(0, import_qunit.test)("a long name widens neither its tile nor its desk", async function(assert) {
+			let restoreA = withUpdatedRealmInfo(realmAURL, { name: longName });
+			try {
+				await visitOperatorMode({ workspaceChooserOpened: true });
+				let matrixService = getService("matrix-service");
+				matrixService.workspaceFavorites = [realmAURL, realmBURL];
+				await settled();
+				await waitFor(`[data-test-favorites-list] [data-test-workspace="${longName}"]`);
+				for (let list of ["[data-test-workspace-list]", "[data-test-favorites-list]"]) {
+					let long = `${list} [data-test-workspace="${longName}"]`;
+					let short = `${list} [data-test-workspace="Workspace B"]`;
+					assert.ok(Math.abs(widthOf(long) - widthOf(short)) < 1, `in ${list}, the long-named workspace is as wide as its short-named neighbor`);
+					assert.ok(widthOf(`${long} [data-test-workspace-name]`) <= widthOf(long), `in ${list}, the name stays within its workspace`);
+				}
+			} finally {
+				restoreA();
+			}
+		});
+	});
+	(0, import_qunit.module)("keyboard", function() {
+		(0, import_qunit.test)("with no favorites and nothing open, the first workspace takes focus on open", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let firstTile = find("[data-test-workspace-recent-list] [data-test-workspace]");
+			assert.ok(firstTile, "a workspace tile is shown");
+			let name = firstTile.getAttribute("data-test-workspace");
+			assert.dom(`[data-test-workspace-recent-list] [data-test-workspace-selected="${name}"]`).exists("the first workspace is selected");
+			assert.dom(`[data-test-workspace-recent-list] [data-test-workspace-button="${name}"]`).isFocused("the first workspace holds focus, so Enter works at once");
+		});
+		(0, import_qunit.test)("Enter on New Workspace opens the create-workspace form without submitting it", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let firstTile = find("[data-test-workspace-recent-list] [data-test-workspace]");
+			assert.ok(firstTile, "a workspace tile is shown");
+			await focus(`[data-test-workspace-recent-list] [data-test-workspace-button="${firstTile.getAttribute("data-test-workspace")}"]`);
+			await pressKey("ArrowLeft");
+			await pressKey("ArrowLeft");
+			assert.dom("[data-test-add-workspace-selected]").exists("New Workspace is selected");
+			await pressKey("Enter");
+			await waitFor("[data-test-create-workspace-modal]");
+			assert.dom("[data-test-create-workspace-modal]").exists("Enter opens the create-workspace modal");
+			assert.dom("[data-test-display-name-field]").exists("the modal shows its form rather than submitting on open");
+		});
+		(0, import_qunit.test)("keys from a workspace's own controls do not move the cursor or open the workspace", async function(assert) {
+			await visitOperatorMode({ workspaceChooserOpened: true });
+			let selected = find("[data-test-workspace-list] [data-test-workspace-selected]");
+			assert.ok(selected, "a workspace is selected on open");
+			let name = selected.getAttribute("data-test-workspace-selected");
+			let star = `[data-test-workspace-list] [data-test-workspace="${name}"] [data-test-workspace-favorite-btn]`;
+			await focus(star);
+			await triggerKeyEvent(star, "keydown", "ArrowRight");
+			await triggerKeyEvent(star, "keydown", "ArrowRight");
+			assert.dom(`[data-test-workspace-selected="${name}"]`).exists("arrow keys from the star do not move the cursor");
+			await triggerKeyEvent(star, "keydown", "Enter");
+			assert.dom("[data-test-dashboard]").exists("Enter from the star does not open a workspace");
+			assert.true(operatorModeState().workspaceChooserOpened, "the dashboard stays open");
+		});
+	});
+	(0, import_qunit.test)("a workspace that is not hosted has no site menu", async function(assert) {
+		await visitOperatorMode({ workspaceChooserOpened: true });
+		assert.dom("[data-test-workspace-list] [data-test-workspace=\"Workspace A\"]").exists();
+		assert.dom(`[data-test-host-trigger="${realmAURL}"]`).doesNotExist("no site menu on a workspace that is not hosted");
+	});
+	(0, import_qunit.module)("background workspace loads", function(hooks) {
+		let { capturedExceptions } = suspendGlobalErrorHook(hooks);
+		(0, import_qunit.test)("a rejected realm load does not surface as a global error", async function(assert) {
+			let realmService = getService("realm");
+			let originalLogin = realmService.login.bind(realmService);
+			let rejectedLoads = 0;
+			realmService.login = async (realmURL) => {
+				if (realmURL === realmAURL) {
+					rejectedLoads++;
+					throw new TypeError("Failed to fetch");
+				}
+				return originalLogin(realmURL);
+			};
+			try {
+				await visitOperatorMode({ workspaceChooserOpened: true });
+				await settled();
+			} finally {
+				realmService.login = originalLogin;
+			}
+			assert.ok(rejectedLoads > 0, `the workspace's realm load ran and rejected, ${rejectedLoads} time(s)`);
+			assert.deepEqual(capturedExceptions.map((error) => String(error)), [], "the rejected load raised nothing globally");
+			assert.dom("[data-test-workspace-list] [data-test-workspace]").exists("the dashboard still shows its workspaces");
+		});
+	});
+});
+//#endregion