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

package/bundled-test-harness/assets/invite-user-to-room-test-CcDA45Ac.js

@@ -1,142 +0,0 @@
-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-CaK5mkT-.js";
-import { t as InviteUserToRoomTool } from "./invite-user-to-room-CyailsJE.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/invite-user-to-room-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 | invite-user-to-room", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL]
-	});
-	let { createAndJoinRoom, getRoomState } = mockMatrixUtils;
-	hooks.beforeEach(function() {
-		getOwner(this).register("service:realm", StubRealmService);
-	});
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {}
-		}));
-	});
-	(0, import_qunit.test)("invites a user to a room", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let toolService = getService("tool-service");
-		let matrixService = getService("matrix-service");
-		await new InviteUserToRoomTool(toolService.toolContext).execute({
-			roomId,
-			userId: "submissionbot"
-		});
-		let membershipEvent = getRoomState(roomId, "m.room.member", matrixService.getFullUserId("submissionbot"));
-		assert.strictEqual(membershipEvent.membership, "invite", "submissionbot invited to room");
-	});
-	(0, import_qunit.test)("refuses to invite an end user", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let command = new InviteUserToRoomTool(getService("tool-service").toolContext);
-		await assert.rejects(command.execute({
-			roomId,
-			userId: "another-person"
-		}), /not the AI bot or the submission bot/, "refuses an invite to a person");
-		assert.throws(() => getRoomState(roomId, "m.room.member", "@another-person:localhost"), /does not exist/, "no membership event was written for the person");
-	});
-	(0, import_qunit.test)("refuses a person whose username matches the writer-account convention", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let command = new InviteUserToRoomTool(getService("tool-service").toolContext);
-		await assert.rejects(command.execute({
-			roomId,
-			userId: "example_writer"
-		}), /not the AI bot or the submission bot/, "refuses an invite to a name a person can register");
-		assert.throws(() => getRoomState(roomId, "m.room.member", "@example_writer:localhost"), /does not exist/, "no membership event was written");
-	});
-	(0, import_qunit.test)("refuses to invite a service user on another homeserver", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let command = new InviteUserToRoomTool(getService("tool-service").toolContext);
-		await assert.rejects(command.execute({
-			roomId,
-			userId: "@submissionbot:other.example"
-		}), /not on this homeserver/, "refuses an invite across homeservers");
-		assert.throws(() => getRoomState(roomId, "m.room.member", "@submissionbot:other.example"), /does not exist/, "no membership event was written");
-	});
-	(0, import_qunit.test)("refuses an id without a leading @", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let command = new InviteUserToRoomTool(getService("tool-service").toolContext);
-		await assert.rejects(command.execute({
-			roomId,
-			userId: "submissionbot:localhost"
-		}), /is not a full Matrix user id/, "refuses a malformed id before Matrix sees it");
-	});
-	(0, import_qunit.test)("MatrixService.inviteUserToRoom refuses a person, whichever caller asks", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let matrixService = getService("matrix-service");
-		await matrixService.ready;
-		await assert.rejects(matrixService.inviteUserToRoom(roomId, "@another-person:localhost"), /not the AI bot or the submission bot/, "refuses an invite that does not come from the tool");
-		assert.throws(() => getRoomState(roomId, "m.room.member", "@another-person:localhost"), /does not exist/, "no membership event was written");
-	});
-	(0, import_qunit.test)("invites the submission bot on a homeserver whose name has a port", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let toolService = getService("tool-service");
-		let matrixService = getService("matrix-service");
-		Object.defineProperty(matrixService, "userId", {
-			configurable: true,
-			get: () => "@testuser:localhost:8008"
-		});
-		assert.strictEqual(matrixService.getFullUserId("submissionbot"), "@submissionbot:localhost:8008", "a bare username takes the server of the signed-in user, port included");
-		await new InviteUserToRoomTool(toolService.toolContext).execute({
-			roomId,
-			userId: "submissionbot"
-		});
-		assert.strictEqual(getRoomState(roomId, "m.room.member", "@submissionbot:localhost:8008").membership, "invite", "submissionbot invited on the port-qualified homeserver");
-	});
-	(0, import_qunit.test)("rejects inviting a user twice", async function(assert) {
-		let roomId = createAndJoinRoom({
-			sender: "@testuser:localhost",
-			name: "room-test"
-		});
-		let command = new InviteUserToRoomTool(getService("tool-service").toolContext);
-		await command.execute({
-			roomId,
-			userId: "submissionbot"
-		});
-		await assert.rejects(command.execute({
-			roomId,
-			userId: "submissionbot"
-		}), /user already in room/, "rejects inviting a user that is already in the room");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/invoke-card-operation-test-DmUtgueM.js

@@ -1,333 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL, jc as isCardErrorJSONAPI } from "./runtime-common-BTaLJEw-.js";
-import { t as InvokeCardOperationTool } from "./invoke-card-operation-CFJSwvH6.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, M as setupCardLogs, P as setupIntegrationTestRealm, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/integration/tools/invoke-card-operation-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var REPORT_MODULE = `
-  import {
-    contains,
-    containsMany,
-    field,
-    linksTo,
-    CardDef,
-    FieldDef,
-  } from "@cardstack/base/card-api";
-  import StringField from "@cardstack/base/string";
-  import { operation, params, bxl } from "@cardstack/base/operations";
-
-  export class ReportComment extends FieldDef {
-    @field body = contains(StringField);
-  }
-
-  export class Activity extends CardDef {
-    @field headline = contains(StringField);
-  }
-
-  export class Report extends CardDef {
-    @field headline = contains(StringField);
-    @field status = contains(StringField);
-    @field comments = containsMany(ReportComment);
-    @field activity = linksTo(() => Activity);
-
-    @operation static addComment = {
-      base: 'transform',
-      params: { body: StringField },
-      append: { to: 'comments', value: { body: params('body') } },
-    };
-
-    @operation static restate = {
-      base: 'transform',
-      params: { headline: StringField },
-      input: bxl\`. + {headline: (.headline // "Restated by default")}\`,
-      set: { headline: params('headline') },
-    };
-
-    @operation static details = {
-      base: 'read',
-    };
-
-    @operation static retire = {
-      base: 'delete',
-    };
-
-    @operation static openReports = {
-      base: 'query',
-      query: { filter: { on: () => Report, eq: { status: 'open' } } },
-    };
-  }
-`;
-function reportFile(headline) {
-	return { data: {
-		type: "card",
-		attributes: {
-			headline,
-			status: "open",
-			comments: []
-		},
-		meta: { adoptsFrom: {
-			module: `${testRealmURL}report`,
-			name: "Report"
-		} }
-	} };
-}
-function realmContents() {
-	return {
-		"report.gts": REPORT_MODULE,
-		"report-commented.json": reportFile("Quarterly Review"),
-		"report-restated.json": reportFile("Before"),
-		"report-read.json": reportFile("Read Me"),
-		"report-unknown.json": reportFile("Unknown Operation"),
-		"report-missing-param.json": reportFile("Missing Param"),
-		"report-queried.json": reportFile("Queried"),
-		"report-realm-given.json": reportFile("Realm Given"),
-		"report-created-from.json": reportFile("Creator"),
-		"report-linked-from.json": reportFile("Linker"),
-		"report-relationships-refused.json": reportFile("Relationships Refused"),
-		"report-retired.json": reportFile("Going Away"),
-		"report-not-offered.json": reportFile("Not Offered"),
-		"report-realm-forwarded.json": reportFile("Realm Forwarded"),
-		"report-realm-defaulted.json": reportFile("Realm Defaulted"),
-		"activity-lab-safety.json": { data: {
-			type: "card",
-			attributes: { headline: "Lab safety" },
-			meta: { adoptsFrom: {
-				module: `${testRealmURL}report`,
-				name: "Activity"
-			} }
-		} }
-	};
-}
-var SESSION_DEFAULT_REALM = "http://test-realm/somewhere-else/";
-var REALM_NAMED_BY_CALLER = "http://test-realm/named-by-the-caller/";
-function recordingTransport() {
-	let sent = [];
-	globalThis._CARDSTACK_OPERATIONS_TRANSPORT = {
-		async send(realmURL, method, envelope) {
-			sent.push({
-				realmURL,
-				method,
-				envelope
-			});
-			return { "atomic:results": [{ data: {
-				type: "card",
-				id: `${testRealmURL}minted`,
-				meta: {}
-			} }] };
-		},
-		defaultWritableRealm() {
-			return SESSION_DEFAULT_REALM;
-		}
-	};
-	return { sent };
-}
-(0, import_qunit.module)("Integration | tools | invoke-card-operation", function(hooks) {
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	setupCardLogs(hooks, async () => getService("loader-service").loader.import("@cardstack/base/card-api"));
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [testRealmURL],
-		autostart: true
-	});
-	let adapter;
-	let hostTransport;
-	hooks.beforeEach(async function() {
-		({adapter} = await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: realmContents()
-		}));
-		await getService("realm").login(testRealmURL);
-		getService("operations");
-		hostTransport = globalThis._CARDSTACK_OPERATIONS_TRANSPORT;
-	});
-	hooks.afterEach(function() {
-		globalThis._CARDSTACK_OPERATIONS_TRANSPORT = hostTransport;
-	});
-	function invoke(input) {
-		return new InvokeCardOperationTool(getService("tool-service").toolContext).execute(input);
-	}
-	async function refusal(input) {
-		try {
-			await invoke(input);
-		} catch (err) {
-			return String(err.message);
-		}
-		throw new Error("expected the invocation to be refused, and it was not");
-	}
-	async function storedCard(localPath) {
-		let file = await adapter.openFile(localPath);
-		if (!file) throw new Error(`${localPath} is not in the realm`);
-		return JSON.parse(file.content);
-	}
-	(0, import_qunit.test)("a declared transform writes the card and answers the lean result", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-commented`,
-			operation: "addComment",
-			payload: { body: "Reviewed and approved." }
-		});
-		assert.strictEqual(result.cardId, `${testRealmURL}report-commented`, "the result names the card the operation wrote");
-		assert.ok(result.version, "and the version that card now holds");
-		assert.ok(result.lastModified > 0, "and when it was written");
-		let stored = await storedCard("report-commented.json");
-		assert.deepEqual(stored.data.attributes.comments, [{ body: "Reviewed and approved." }], "the payload reached the card as the declaration describes");
-	});
-	(0, import_qunit.test)("a declared read answers the document rather than a lean result", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-read`,
-			operation: "details"
-		});
-		let document = result.document;
-		assert.strictEqual(document.data.id, `${testRealmURL}report-read`, "the document is the card that was read");
-		assert.strictEqual(document.data.attributes.headline, "Read Me", "and it carries the card values");
-		assert.notOk(result.cardId, "a read names no card it wrote");
-	});
-	(0, import_qunit.test)("a class-scoped create mints a card in the realm it is given", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-created-from`,
-			operation: "create",
-			payload: { headline: "Minted" },
-			realm: testRealmURL
-		});
-		assert.ok(result.cardId.startsWith(testRealmURL), `the new card was minted in the realm it was given: ${result.cardId}`);
-		assert.notStrictEqual(result.cardId, `${testRealmURL}report-created-from`, "and it is a new card rather than the one that named its type");
-		let stored = await storedCard(`${result.cardId.slice(testRealmURL.length)}.json`);
-		assert.strictEqual(stored.data.attributes.headline, "Minted", "the field values the caller supplied reached the new card");
-		assert.strictEqual(stored.data.meta.adoptsFrom.name, "Report", "and its type came from the card the call named");
-	});
-	(0, import_qunit.test)("a create is minted holding the links it was given", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-linked-from`,
-			operation: "create",
-			payload: { headline: "Linked" },
-			relationships: { activity: { links: { self: `${testRealmURL}activity-lab-safety` } } },
-			realm: testRealmURL
-		});
-		let stored = await storedCard(`${result.cardId.slice(testRealmURL.length)}.json`);
-		let link = stored.data.relationships?.activity?.links?.self;
-		assert.strictEqual(link === void 0 ? void 0 : new URL(link, result.cardId).href, `${testRealmURL}activity-lab-safety`, "the new card holds the link the caller named, which it could not if links travelled as attributes");
-		assert.strictEqual(stored.data.attributes.headline, "Linked", "and its field values arrived beside them");
-		assert.strictEqual(stored.data.attributes.activity, void 0, "with nothing written under the link field as an attribute");
-	});
-	(0, import_qunit.test)("relationships are refused for an operation that mints no card", async function(assert) {
-		let { sent } = recordingTransport();
-		let message = await refusal({
-			cardId: `${testRealmURL}report-relationships-refused`,
-			operation: "addComment",
-			payload: { body: "Somewhere else" },
-			relationships: { activity: { links: { self: `${testRealmURL}activity-lab-safety` } } }
-		});
-		assert.true(message.includes("no new card for \"relationships\" to describe"), `the refusal says why they have nowhere to go: ${message}`);
-		assert.strictEqual(sent.length, 0, "and nothing was sent to the realm");
-	});
-	(0, import_qunit.test)("a declared delete answers with nothing left to describe", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-retired`,
-			operation: "retire"
-		});
-		assert.notOk(result.cardId, "a delete names no card it wrote");
-		assert.notOk(result.version, "and no version it left behind");
-		assert.notOk(result.document, "and no document");
-		assert.false(await adapter.exists("report-retired.json"), "and the card is gone from the realm");
-	});
-	(0, import_qunit.test)("a behavior every card carries is not invoked here", async function(assert) {
-		let { sent } = recordingTransport();
-		let message = await refusal({
-			cardId: `${testRealmURL}report-not-offered`,
-			operation: "update",
-			payload: { attributes: { headline: "Patched" } }
-		});
-		assert.true(message.includes("is a behavior every card carries"), `the refusal says what "update" is: ${message}`);
-		assert.true(message.includes("patch-fields"), `and where a card is changed instead: ${message}`);
-		assert.strictEqual(sent.length, 0, "and nothing was sent to the realm");
-	});
-	(0, import_qunit.test)("a create is sent to the realm it was given", async function(assert) {
-		let { sent } = recordingTransport();
-		await invoke({
-			cardId: `${testRealmURL}report-realm-forwarded`,
-			operation: "create",
-			payload: { headline: "Elsewhere" },
-			realm: REALM_NAMED_BY_CALLER
-		});
-		assert.strictEqual(sent.length, 1, "one batch was sent");
-		assert.strictEqual(sent[0].realmURL, REALM_NAMED_BY_CALLER, "to the realm the caller named, which is neither the realm holding the card nor the one this session writes to by default");
-	});
-	(0, import_qunit.test)("a create with no realm is sent to the realm holding the card that named its type", async function(assert) {
-		let { sent } = recordingTransport();
-		await invoke({
-			cardId: `${testRealmURL}report-realm-defaulted`,
-			operation: "create",
-			payload: { headline: "Beside It" }
-		});
-		assert.strictEqual(sent.length, 1, "one batch was sent");
-		assert.strictEqual(sent[0].realmURL, testRealmURL, "to the realm holding the target card, not to the realm this session writes to by default");
-	});
-	(0, import_qunit.test)("an unknown operation is refused, naming the ones the card carries", async function(assert) {
-		let message = await refusal({
-			cardId: `${testRealmURL}report-unknown`,
-			operation: "escalate"
-		});
-		assert.true(message.includes("\"escalate\" is not an operation Report carries"), `the refusal names what was asked for: ${message}`);
-		for (let name of [
-			"addComment",
-			"restate",
-			"details",
-			"retire",
-			"create"
-		]) assert.true(message.includes(name), `the refusal offers "${name}": ${message}`);
-		assert.false(message.includes("openReports"), "and does not offer a query, which answers a live set of results");
-		assert.false(message.includes("update"), "nor a behavior every card carries, which has its own tool");
-		assert.false(message.includes("atomic"), "nor the batch member, which is not an operation");
-	});
-	(0, import_qunit.test)("a payload missing a declared param is refused before any request", async function(assert) {
-		let { sent } = recordingTransport();
-		let message = await refusal({
-			cardId: `${testRealmURL}report-missing-param`,
-			operation: "addComment",
-			payload: { note: "not the declared name" }
-		});
-		assert.true(message.includes("requires a value for params(\"body\")"), `the refusal names the param that has no value: ${message}`);
-		assert.strictEqual(sent.length, 0, "and nothing was sent to the realm");
-	});
-	(0, import_qunit.test)("an input program supplies a param the caller left out", async function(assert) {
-		let result = await invoke({
-			cardId: `${testRealmURL}report-restated`,
-			operation: "restate"
-		});
-		assert.strictEqual(result.cardId, `${testRealmURL}report-restated`, "the invocation ran rather than being refused for the param it did not send");
-		let stored = await storedCard("report-restated.json");
-		assert.strictEqual(stored.data.attributes.headline, "Restated by default", "and the value the input program produced is what the operation used");
-	});
-	(0, import_qunit.test)("a query is refused, since it answers a live set of results", async function(assert) {
-		let message = await refusal({
-			cardId: `${testRealmURL}report-queried`,
-			operation: "openReports"
-		});
-		assert.true(message.includes("\"openReports\" is a query operation"), `the refusal says what the name is: ${message}`);
-		assert.true(message.includes("search-entries"), `and where results are read instead: ${message}`);
-	});
-	(0, import_qunit.test)("an operation that acts on the card cannot be given a realm to run in", async function(assert) {
-		let { sent } = recordingTransport();
-		let message = await refusal({
-			cardId: `${testRealmURL}report-realm-given`,
-			operation: "addComment",
-			payload: { body: "Somewhere else" },
-			realm: testRealmURL
-		});
-		assert.true(message.includes("runs in the realm that holds it"), `the refusal says where the operation runs: ${message}`);
-		assert.strictEqual(sent.length, 0, "and nothing was sent to the realm");
-	});
-	(0, import_qunit.test)("a card that does not load is reported as the reason the operation did not run", async function(assert) {
-		let missing = `${testRealmURL}report-nonexistent`;
-		let message = await refusal({
-			cardId: missing,
-			operation: "addComment",
-			payload: { body: "Nowhere" }
-		});
-		assert.true(message.includes(missing), `the refusal names the card that did not load: ${message}`);
-		assert.ok(isCardErrorJSONAPI(await getService("store").get(missing)), "and the store is what reported it missing");
-	});
-});
-//#endregion

package/bundled-test-harness/assets/isolated-render-test-B2eXNHu6.js

@@ -1,51 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { wt as setComponentTemplate } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { H as templateFactory } from "./index-DaCZcoCY-CgzbilMy.js";
-import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
-import "./component-BJO47HTh.js";
-import { t as Component } from "./dist-CkA1rgqO.js";
-import "./template-factory-ds9s0u8l.js";
-import { T as settled } from "./dist-BOAdzfkP.js";
-import { a as teardown, i as render } from "./render-service-Bc0F9vjl.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { lt as setupRenderingTest } from "./mock-matrix-Dd8k0DNa.js";
-//#region tests/unit/lib/isolated-render-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var destroyCount = 0;
-var TeardownProbe = class extends Component {
-	constructor(owner, args) {
-		super(owner, args);
-		registerDestructor(this, () => destroyCount++);
-	}
-	static {
-		setComponentTemplate(templateFactory({
-			"id": "S8AHJ/+X",
-			"block": "[[[10,0],[14,\"data-render-probe\",\"\"],[12],[1,\"probe\"],[13]],[],[]]",
-			"moduleName": "/home/runner/work/boxel/boxel/packages/host/tests/unit/lib/isolated-render-test.gts",
-			"isStrictMode": true
-		}), this);
-	}
-};
-(0, import_qunit.module)("Unit | isolated-render", function(hooks) {
-	setupRenderingTest(hooks);
-	hooks.beforeEach(function() {
-		destroyCount = 0;
-	});
-	(0, import_qunit.test)("render tears down the previous live tree before rerendering", async function(assert) {
-		let element = document.createElement("div");
-		document.body.appendChild(element);
-		try {
-			render(TeardownProbe, element, this.owner);
-			assert.strictEqual(destroyCount, 0, "initial render keeps the component alive");
-			render(TeardownProbe, element, this.owner);
-			await settled();
-			assert.strictEqual(destroyCount, 1, "rerender destroys the previous component tree before replacing it");
-			teardown(element);
-			await settled();
-			assert.strictEqual(destroyCount, 2, "explicit teardown destroys the current component tree");
-		} finally {
-			element.remove();
-		}
-	});
-});
-//#endregion