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

package/bundled-test-harness/assets/copy-and-edit-test-DiXTQNTF.js

@@ -1,292 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { G as realmURL } from "./constants-Icc0nFW-.js";
-import { t as StackItem } from "./stack-item-DVxyTuhM.js";
-import { T as settled } from "./dist-BOAdzfkP.js";
-import { t as CopyAndEditTool } from "./copy-and-edit-xnb1V7j9.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-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/copy-and-edit-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var otherRealmURL = "http://other-realm/test2/";
-(0, import_qunit.module)("Integration | tools | copy-and-edit", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, otherRealmURL]
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: testRealmURL,
-			contents: {
-				"content-card.gts": `
-          import { CardDef, contains, field, linksTo, linksToMany } from "@cardstack/base/card-api";
-          import StringField from "@cardstack/base/string";
-
-          export class Child extends CardDef {
-            static displayName = 'Child';
-            @field name = contains(StringField);
-          }
-
-          export class Parent extends CardDef {
-            static displayName = 'Parent';
-            @field child = linksTo(Child);
-            @field children = linksToMany(() => Child);
-          }
-        `,
-				"Child/og.json": { data: {
-					type: "card",
-					attributes: { name: "Original" },
-					meta: { adoptsFrom: {
-						module: "../content-card",
-						name: "Child"
-					} }
-				} },
-				"Parent/root.json": { data: {
-					type: "card",
-					relationships: {
-						child: { data: {
-							type: "card",
-							id: "../Child/og"
-						} },
-						"children.0": { links: { self: "../Child/og" } }
-					},
-					meta: { adoptsFrom: {
-						module: "../content-card",
-						name: "Parent"
-					} }
-				} },
-				"simple-card.gts": `
-          import { CardDef, field, contains } from "@cardstack/base/card-api";
-          import StringField from "@cardstack/base/string";
-
-          export class Theme extends CardDef {
-            static displayName = 'Theme';
-            @field name = contains(StringField);
-          }
-
-          export class SimpleCard extends CardDef {
-            static displayName = 'SimpleCard';
-          }
-        `,
-				"Theme/og.json": { data: {
-					type: "card",
-					attributes: { name: "Original Theme" },
-					meta: { adoptsFrom: {
-						module: "@cardstack/base/theme",
-						name: "default"
-					} }
-				} },
-				"simple-card-instance.json": { data: {
-					type: "card",
-					attributes: {},
-					relationships: { "cardInfo.theme": { data: {
-						type: "card",
-						id: "./Theme/og"
-					} } },
-					meta: { adoptsFrom: {
-						module: "./simple-card",
-						name: "SimpleCard"
-					} }
-				} }
-			}
-		}));
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			realmURL: otherRealmURL,
-			contents: {
-				"content-card.gts": `
-          import { CardDef, contains, field } from "@cardstack/base/card-api";
-          import StringField from "@cardstack/base/string";
-
-          export class Child extends CardDef {
-            static displayName = 'Child';
-            @field name = contains(StringField);
-          }
-        `,
-				"Child/remote.json": { data: {
-					type: "card",
-					attributes: { name: "RemoteChild" },
-					meta: { adoptsFrom: {
-						module: `${testRealmURL}content-card`,
-						name: "Child"
-					} }
-				} }
-			}
-		}));
-		let realmService = getService("realm");
-		await realmService.login(testRealmURL);
-		await realmService.login(otherRealmURL);
-	});
-	(0, import_qunit.test)("copies card and relinks linksTo parent (same realm)", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let parentCard = await store.get(`${testRealmURL}Parent/root`);
-		let childCard = await store.get(`${testRealmURL}Child/og`);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: parentCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: childCard.id,
-			format: "isolated",
-			stackIndex: 0,
-			relationshipContext: {
-				fieldName: "child",
-				fieldType: "linksTo"
-			}
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
-		await settled();
-		let updatedParent = await store.get(parentCard.id);
-		let newChildId = updatedParent.child?.id ?? updatedParent.child;
-		assert.ok(newChildId, "parent now links to a child (linksTo)");
-		assert.notEqual(newChildId, childCard.id, "parent links to a different child after copy");
-		if (newChildId) {
-			let copiedChild = await store.get(newChildId);
-			assert.strictEqual(copiedChild[realmURL]?.href, testRealmURL, "new child is in same realm as source");
-		}
-	});
-	(0, import_qunit.test)("copies card and relinks nested linksTo parent when only leaf field name is provided", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let parentCard = await store.get(`${testRealmURL}simple-card-instance`);
-		let originalTheme = await store.get(`${testRealmURL}Theme/og`);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: parentCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: originalTheme.id,
-			format: "isolated",
-			stackIndex: 0,
-			relationshipContext: {
-				fieldName: "theme",
-				fieldType: "linksTo"
-			}
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: originalTheme });
-		await settled();
-		let updatedParent = await store.get(parentCard.id);
-		let linkedThemeId = updatedParent.cardInfo?.theme?.id ?? updatedParent.cardInfo?.theme;
-		assert.ok(linkedThemeId, "parent cardInfo.theme is set after copy");
-		assert.notEqual(linkedThemeId, originalTheme.id, "cardInfo.theme points to copied theme");
-	});
-	(0, import_qunit.test)("copies card without linked parent (query-derived stack) and does not throw", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let childCard = await store.get(`${testRealmURL}Child/og`);
-		operatorModeStateService.clearStacks();
-		operatorModeStateService.addItemToStack(operatorModeStateService.createStackItem(`${testRealmURL}index`, 0, "isolated"));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
-		assert.ok(true, "command completes without throwing when no parent linked");
-	});
-	(0, import_qunit.test)("copies card in single stack and replaces current item", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let simpleCard = await store.get(`${testRealmURL}simple-card-instance`);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: simpleCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: simpleCard });
-		await settled();
-		let stacks = operatorModeStateService.state?.stacks ?? [];
-		let topItemId = stacks[0]?.[stacks[0].length - 1]?.id;
-		assert.ok(topItemId, "stack has a top item after copy");
-		assert.notEqual(topItemId, simpleCard.id, "stack item replaced with copied card");
-	});
-	(0, import_qunit.test)("copies card and relinks linksToMany parent (same realm)", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let parentCard = await store.get(`${testRealmURL}Parent/root`);
-		let childCard = await store.get(`${testRealmURL}Child/og`);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: parentCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: childCard.id,
-			format: "isolated",
-			stackIndex: 0,
-			relationshipContext: {
-				fieldName: "children",
-				fieldType: "linksToMany"
-			}
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: childCard });
-		await settled();
-		let newChildrenIds = (await store.get(parentCard.id)).children?.map((c) => c?.id ?? c) ?? [];
-		assert.ok(newChildrenIds.some((id) => id && id !== childCard.id), "linksToMany children updated to include copied child");
-	});
-	(0, import_qunit.test)("copies linked card and relinks linksTo parent (cross realm)", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let parentCard = await store.get(`${testRealmURL}Parent/root`);
-		let remoteChild = await store.get(`${otherRealmURL}Child/remote`);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: parentCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: remoteChild.id,
-			format: "isolated",
-			stackIndex: 0,
-			relationshipContext: {
-				fieldName: "child",
-				fieldType: "linksTo"
-			}
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: remoteChild });
-		await settled();
-		let updatedParent = await store.get(parentCard.id);
-		let newChildId = updatedParent.child?.id ?? updatedParent.child;
-		assert.ok(newChildId, "parent now links to a child after copy");
-		assert.notEqual(newChildId, remoteChild.id, "parent links to a different child after copy");
-		assert.ok(newChildId.startsWith(otherRealmURL), "copied child remains in original remote realm");
-	});
-	(0, import_qunit.test)("copies card and relinks linksToMany parent (cross realm)", async function(assert) {
-		let toolService = getService("tool-service");
-		let store = getService("store");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let parentCard = await store.get(`${testRealmURL}Parent/root`);
-		let remoteChild = await store.get(`${otherRealmURL}Child/remote`);
-		parentCard.children = [remoteChild];
-		if (parentCard.id) store.save(parentCard.id);
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: parentCard.id,
-			format: "isolated",
-			stackIndex: 0
-		}));
-		operatorModeStateService.addItemToStack(new StackItem({
-			id: remoteChild.id,
-			format: "isolated",
-			stackIndex: 0,
-			relationshipContext: {
-				fieldName: "children",
-				fieldType: "linksToMany"
-			}
-		}));
-		await new CopyAndEditTool(toolService.toolContext).execute({ card: remoteChild });
-		await settled();
-		let newChildrenIds = (await store.get(parentCard.id)).children?.map((c) => c?.id ?? c) ?? [];
-		assert.ok(newChildrenIds.some((id) => id && id !== remoteChild.id), "linksToMany children updated to include copied child");
-		assert.ok(newChildrenIds.some((id) => id && id.startsWith(otherRealmURL)), "copied child remains in original remote realm");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/copy-card-test-ys7GquUY.js

@@ -1,218 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { G as realmURL } from "./constants-Icc0nFW-.js";
-import { r as basicMappings } from "./ai-BFUROO-8.js";
-import { t as StackItem } from "./stack-item-DVxyTuhM.js";
-import { t as CopyCardToRealmTool } from "./copy-card-D0YSVIfv.js";
-import { t as CopyCardToStackTool } from "./copy-card-to-stack-DD_vzJ5Q.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-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/copy-card-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealm2URL = "http://test-realm/test2/";
-(0, import_qunit.module)("Integration | tools | copy-card", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, testRealm2URL]
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => {
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: testRealmURL,
-				contents: {
-					"pet.gts": `
-          import { contains, field, CardDef } from "@cardstack/base/card-api";
-          import StringField from "@cardstack/base/string";
-          export class Pet extends CardDef {
-            static displayName = 'Pet';
-            @field firstName = contains(StringField);
-          }
-        `,
-					"Pet/mango.json": { data: {
-						type: "card",
-						attributes: { firstName: "Mango" },
-						meta: { adoptsFrom: {
-							module: "../pet",
-							name: "Pet"
-						} }
-					} }
-				}
-			});
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: testRealm2URL,
-				contents: {
-					"index.json": { data: {
-						type: "card",
-						meta: { adoptsFrom: {
-							module: "@cardstack/base/cards-grid",
-							name: "CardsGrid"
-						} }
-					} },
-					"Pet/fluffy.json": { data: {
-						type: "card",
-						attributes: { firstName: "Fluffy" },
-						meta: { adoptsFrom: {
-							module: `${testRealmURL}pet`,
-							name: "Pet"
-						} }
-					} }
-				}
-			});
-		});
-		let realmService = getService("realm");
-		await realmService.login(testRealmURL);
-		await realmService.login(testRealm2URL);
-	});
-	(0, import_qunit.module)("CopyCardToRealmTool", function() {
-		(0, import_qunit.test)("copies card to target realm", async function(assert) {
-			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
-			let sourceCardUrl = `${testRealmURL}Pet/mango`;
-			let targetRealm = testRealm2URL;
-			let store = getService("store");
-			let sourceCard = await store.get(sourceCardUrl);
-			assert.ok(sourceCard, "source card exists");
-			assert.strictEqual(sourceCard[realmURL]?.href, testRealmURL, "source card is from expected realm");
-			let result = await copyCardCommand.execute({
-				sourceCard,
-				targetRealm
-			});
-			assert.ok(result.newCardId, "new card URL is returned");
-			assert.true(result.newCardId.startsWith(targetRealm), "new card is created in target realm");
-			assert.notEqual(result.newCardId, sourceCardUrl, "new card has different URL than source");
-			let copiedCard = await store.get(result.newCardId);
-			assert.ok(copiedCard, "copied card exists in store");
-			assert.strictEqual(copiedCard[realmURL]?.href, targetRealm, "copied card is in target realm");
-		});
-		(0, import_qunit.test)("puts the copy beneath localDir, in a folder named after its type", async function(assert) {
-			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
-			let store = getService("store");
-			let sourceCard = await store.get(`${testRealmURL}Pet/mango`);
-			let result = await copyCardCommand.execute({
-				sourceCard,
-				targetRealm: testRealm2URL,
-				localDir: "projects/acme"
-			});
-			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy lands at <targetRealm><localDir>/<CardTypeName>/<generated-id>, got ${result.newCardId}`);
-			let copiedCard = await store.get(result.newCardId);
-			assert.strictEqual(copiedCard.firstName, "Mango", "the copy is readable at newCardId");
-		});
-		(0, import_qunit.test)("reads a leading slash in localDir as the realm root", async function(assert) {
-			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
-			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
-			let result = await copyCardCommand.execute({
-				sourceCard,
-				targetRealm: testRealm2URL,
-				localDir: "/projects/acme"
-			});
-			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy stays inside the target realm, got ${result.newCardId}`);
-		});
-		(0, import_qunit.test)("refuses a localDir that leaves the target realm", async function(assert) {
-			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
-			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
-			for (let localDir of [
-				"../test",
-				"projects/../../test",
-				"%2e%2e/test"
-			]) await assert.rejects(copyCardCommand.execute({
-				sourceCard,
-				targetRealm: testRealm2URL,
-				localDir
-			}), /is not a folder inside/, `localDir "${localDir}" is refused`);
-		});
-		(0, import_qunit.test)("the tool schema describes how targetRealm and localDir make up the path of the copy", async function(assert) {
-			let loader = getService("loader-service").loader;
-			let cardAPI = await loader.import("@cardstack/base/card-api");
-			let mappings = await basicMappings(loader);
-			let { properties } = (await new CopyCardToRealmTool(getService("tool-service").toolContext).getInputJsonSchema(cardAPI, mappings, true)).attributes;
-			assert.true(properties.targetRealm?.description?.includes("<targetRealm><localDir>/<CardTypeName>/<generated-id>.json"), "targetRealm states the path the copy is written to");
-			assert.true(properties.localDir?.description?.includes("projects/acme/Incident/<generated-id>.json"), "localDir gives an example of the folder it adds and the generated file name");
-		});
-		(0, import_qunit.test)("errors when user does not have write permissions to target realm", async function(assert) {
-			let copyCardCommand = new CopyCardToRealmTool(getService("tool-service").toolContext);
-			let sourceCardUrl = `${testRealmURL}Pet/mango`;
-			let targetRealm = testRealm2URL;
-			let realmService = getService("realm");
-			realmService.logout();
-			await realmService.login(testRealmURL);
-			let sourceCard = await getService("store").get(sourceCardUrl);
-			assert.ok(sourceCard, "source card exists");
-			try {
-				await copyCardCommand.execute({
-					sourceCard,
-					targetRealm
-				});
-				assert.ok(false, "should have thrown an error");
-			} catch (error) {
-				assert.ok(error instanceof Error, "throws an error");
-				assert.strictEqual(error.message, `Do not have write permissions to ${targetRealm}`, "error message indicates write permission issue");
-			}
-		});
-	});
-	(0, import_qunit.module)("CopyCardToStackTool", function() {
-		(0, import_qunit.test)("copies card to stack when valid targetStackIndex is provided", async function(assert) {
-			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
-			let sourceCardUrl = `${testRealmURL}Pet/mango`;
-			let targetStackIndex = 0;
-			let targetCardUrl = `${testRealm2URL}Pet/fluffy`;
-			let operatorModeStateService = getService("operator-mode-state-service");
-			operatorModeStateService.topMostStackItems = () => [new StackItem({
-				id: targetCardUrl,
-				format: "isolated",
-				stackIndex: 0
-			})];
-			let store = getService("store");
-			let sourceCard = await store.get(sourceCardUrl);
-			assert.ok(sourceCard, "source card exists");
-			assert.strictEqual(sourceCard[realmURL]?.href, testRealmURL, "source card is from expected realm");
-			let result = await copyCardToStackCommand.execute({
-				sourceCard,
-				targetStackIndex
-			});
-			assert.ok(result.newCardId, "new card URL is returned");
-			assert.true(result.newCardId.startsWith(testRealm2URL), "new card is created in target realm");
-			assert.notEqual(result.newCardId, sourceCardUrl, "new card has different URL than source");
-			let copiedCard = await store.get(result.newCardId);
-			assert.ok(copiedCard, "copied card exists in store");
-			assert.strictEqual(copiedCard[realmURL]?.href, testRealm2URL, "copied card is in target realm");
-		});
-		(0, import_qunit.test)("puts the copy beneath localDir in the target stack realm", async function(assert) {
-			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
-			let operatorModeStateService = getService("operator-mode-state-service");
-			operatorModeStateService.topMostStackItems = () => [new StackItem({
-				id: `${testRealm2URL}Pet/fluffy`,
-				format: "isolated",
-				stackIndex: 0
-			})];
-			let sourceCard = await getService("store").get(`${testRealmURL}Pet/mango`);
-			let result = await copyCardToStackCommand.execute({
-				sourceCard,
-				targetStackIndex: 0,
-				localDir: "projects/acme"
-			});
-			assert.true(result.newCardId.startsWith(`${testRealm2URL}projects/acme/Pet/`), `copy lands beneath localDir in the stack's realm, got ${result.newCardId}`);
-		});
-		(0, import_qunit.test)("errors when targetStackIndex does not exist", async function(assert) {
-			let copyCardToStackCommand = new CopyCardToStackTool(getService("tool-service").toolContext);
-			let sourceCardUrl = `${testRealmURL}Pet/mango`;
-			let targetStackIndex = 99;
-			let sourceCard = await getService("store").get(sourceCardUrl);
-			try {
-				await copyCardToStackCommand.execute({
-					sourceCard,
-					targetStackIndex
-				});
-				assert.ok(false, "should have thrown an error");
-			} catch (error) {
-				assert.ok(error instanceof Error, "throws an error");
-				assert.true(error.message.includes("Cannot find topmost card in target stack"), "error message mentions missing stack");
-			}
-		});
-	});
-});
-//#endregion

package/bundled-test-harness/assets/copy-file-to-realm-test-Gn0Wn4vT.js

@@ -1,148 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { t as CopyFileToRealmTool } from "./copy-file-to-realm-_zLGtK4w.js";
-import { t as ShowFileTool } from "./show-file-DpZ0VqpD.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-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/copy-file-to-realm-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var testRealm2URL = "http://test-realm/test2/";
-(0, import_qunit.module)("Integration | tools | copy-file-to-realm", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL, testRealm2URL]
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => {
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: testRealmURL,
-				contents: {
-					"hello.txt": "Hello World!",
-					"nested/deep.txt": "Nested file content"
-				}
-			});
-			await setupIntegrationTestRealm({
-				mockMatrixUtils,
-				realmURL: testRealm2URL,
-				contents: { "existing.txt": "I already exist" }
-			});
-		});
-		let realmService = getService("realm");
-		await realmService.login(testRealmURL);
-		await realmService.login(testRealm2URL);
-	});
-	(0, import_qunit.test)("copies file to target realm", async function(assert) {
-		let result = await new CopyFileToRealmTool(getService("tool-service").toolContext).execute({
-			sourceFileIdentifier: `${testRealmURL}hello.txt`,
-			targetRealm: testRealm2URL
-		});
-		assert.ok(result.newFileIdentifier, "new file URL is returned");
-		assert.true(result.newFileIdentifier.startsWith(testRealm2URL), "new file is in target realm");
-		let copied = await getService("card-service").getSource(new URL(result.newFileIdentifier));
-		assert.strictEqual(copied.status, 200, "copied file exists");
-		assert.strictEqual(copied.content, "Hello World!", "content matches");
-	});
-	(0, import_qunit.test)("handles filename conflicts by creating non-conflicting name", async function(assert) {
-		let copyFileCommand = new CopyFileToRealmTool(getService("tool-service").toolContext);
-		await copyFileCommand.execute({
-			sourceFileIdentifier: `${testRealmURL}hello.txt`,
-			targetRealm: testRealm2URL
-		});
-		let result = await copyFileCommand.execute({
-			sourceFileIdentifier: `${testRealmURL}hello.txt`,
-			targetRealm: testRealm2URL
-		});
-		assert.ok(result.newFileIdentifier, "new file URL is returned");
-		assert.true(result.newFileIdentifier.startsWith(testRealm2URL), "new file is in target realm");
-		assert.notStrictEqual(result.newFileIdentifier, `${testRealm2URL}hello.txt`, "file URL is different from the original (conflict resolved)");
-		let copied = await getService("card-service").getSource(new URL(result.newFileIdentifier));
-		assert.strictEqual(copied.status, 200, "copied file exists");
-		assert.strictEqual(copied.content, "Hello World!", "content matches");
-	});
-	(0, import_qunit.test)("after copying, show file command switches to code submode with correct file URL", async function(assert) {
-		let toolService = getService("tool-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		operatorModeStateService.restore({
-			stacks: [[]],
-			submode: "interact"
-		});
-		let result = await new CopyFileToRealmTool(toolService.toolContext).execute({
-			sourceFileIdentifier: `${testRealmURL}hello.txt`,
-			targetRealm: testRealm2URL
-		});
-		assert.ok(result.newFileIdentifier, "new file URL is returned");
-		await new ShowFileTool(toolService.toolContext).execute({ fileIdentifier: result.newFileIdentifier });
-		assert.strictEqual(operatorModeStateService.state?.submode, "code", "submode is switched to code");
-		assert.strictEqual(operatorModeStateService.state?.codePath, result.newFileIdentifier, "code path is set to the copied file URL");
-	});
-	(0, import_qunit.test)("show file command opens a prefix-form file identifier", async function(assert) {
-		let toolService = getService("tool-service");
-		let operatorModeStateService = getService("operator-mode-state-service");
-		let { virtualNetwork } = getService("network");
-		let testRealmPrefix = "@test/show-realm/";
-		virtualNetwork.addRealmMapping(testRealmPrefix, testRealmURL);
-		try {
-			operatorModeStateService.restore({
-				stacks: [[]],
-				submode: "interact"
-			});
-			await new ShowFileTool(toolService.toolContext).execute({ fileIdentifier: `${testRealmPrefix}hello.txt` });
-			assert.strictEqual(operatorModeStateService.state?.submode, "code", "submode is switched to code");
-			let codePath = operatorModeStateService.state?.codePath;
-			assert.strictEqual(codePath ? virtualNetwork.toURL(codePath).href : void 0, `${testRealmURL}hello.txt`, "code path is the file the prefix-form identifier names");
-		} finally {
-			await operatorModeStateService.updateCodePath(null);
-			virtualNetwork.removeRealmMapping(testRealmPrefix);
-		}
-	});
-	(0, import_qunit.test)("copies a file named by prefix-form identifiers", async function(assert) {
-		let toolService = getService("tool-service");
-		let { virtualNetwork } = getService("network");
-		let sourcePrefix = "@test/copy-source/";
-		let targetPrefix = "@test/copy-target/";
-		virtualNetwork.addRealmMapping(sourcePrefix, testRealmURL);
-		virtualNetwork.addRealmMapping(targetPrefix, testRealm2URL);
-		try {
-			let result = await new CopyFileToRealmTool(toolService.toolContext).execute({
-				sourceFileIdentifier: `${sourcePrefix}hello.txt`,
-				targetRealm: targetPrefix
-			});
-			assert.strictEqual(result.newFileIdentifier, `${targetPrefix}hello.txt`, "the new file identifier keeps the prefix form");
-			let response = await fetch(new URL("hello.txt", testRealm2URL));
-			assert.strictEqual(response.status, 200, "copied file exists");
-			assert.strictEqual(await response.text(), "Hello World!", "content matches");
-		} finally {
-			virtualNetwork.removeRealmMapping(sourcePrefix);
-			virtualNetwork.removeRealmMapping(targetPrefix);
-		}
-	});
-	(0, import_qunit.test)("refuses a source identifier that names a directory", async function(assert) {
-		let toolService = getService("tool-service");
-		await assert.rejects(new CopyFileToRealmTool(toolService.toolContext).execute({
-			sourceFileIdentifier: `${testRealmURL}nested/`,
-			targetRealm: testRealm2URL
-		}), /does not name a file/);
-	});
-	(0, import_qunit.test)("errors when user does not have write permissions to target realm", async function(assert) {
-		let copyFileCommand = new CopyFileToRealmTool(getService("tool-service").toolContext);
-		let realmService = getService("realm");
-		realmService.logout();
-		await realmService.login(testRealmURL);
-		try {
-			await copyFileCommand.execute({
-				sourceFileIdentifier: `${testRealmURL}hello.txt`,
-				targetRealm: testRealm2URL
-			});
-			assert.ok(false, "should have thrown an error");
-		} catch (error) {
-			assert.ok(error instanceof Error, "throws an error");
-			assert.strictEqual(error.message, `Do not have write permissions to ${testRealm2URL}`, "error message indicates write permission issue");
-		}
-	});
-});
-//#endregion