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

package/bundled-test-harness/assets/card-thunk-error-test-L0pvg4Ce.js

@@ -1,48 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { lt as setupRenderingTest } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-//#region tests/unit/card-thunk-error-test.ts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-(0, import_qunit.module)("Unit | card field thunk errors", function(hooks) {
-	setupRenderingTest(hooks);
-	let fieldKinds = (api) => [
-		[
-			"linksTo",
-			"src",
-			api.linksTo
-		],
-		[
-			"linksToMany",
-			"links",
-			api.linksToMany
-		],
-		[
-			"contains",
-			"meta",
-			api.contains
-		],
-		[
-			"containsMany",
-			"items",
-			api.containsMany
-		]
-	];
-	(0, import_qunit.test)("an undefined field card class names the field, the owner, and both causes", async function(assert) {
-		let api = await getService("loader-service").loader.import("@cardstack/base/card-api");
-		class Broken extends api.CardDef {}
-		for (let [label, fieldName, fieldFn] of fieldKinds(api)) assert.throws(() => api.field(Broken.prototype, fieldName, { initializer: () => fieldFn(void 0) }), (err) => new RegExp(`field '${fieldName}' on 'Broken'`).test(err.message) && /export shape/.test(err.message) && /cyclic dependency/.test(err.message), `${label} names the field, the owner, and both causes`);
-	});
-	(0, import_qunit.test)("a thunk resolving to undefined names the field at first read", async function(assert) {
-		let loader = getService("loader-service").loader;
-		let api = await loader.import("@cardstack/base/card-api");
-		let { isField } = await loader.import("@cardstack/runtime-common");
-		class BrokenThunk extends api.CardDef {}
-		for (let [label, fieldName, fieldFn] of fieldKinds(api)) {
-			let field = api.field(BrokenThunk.prototype, fieldName, { initializer: () => fieldFn(() => void 0) })?.get?.[isField];
-			assert.ok(field, `${label} field is registered`);
-			assert.throws(() => field.card, (err) => new RegExp(`field '${fieldName}' on 'BrokenThunk'`).test(err.message) && /export shape/.test(err.message) && /cyclic dependency/.test(err.message), `${label} thunk form names the field and owner at first read`);
-		}
-	});
-});
-//#endregion

package/bundled-test-harness/assets/card-type-service-test-B2dhqxSD.js

@@ -1,161 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { O as baseRealm } from "./constants-Icc0nFW-.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, 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/services/card-type-service-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var COLORISH_FIELD_COUNT = 8;
-(0, import_qunit.module)("Integration | services | card-type-service", function(hooks) {
-	let requestLog = [];
-	let failNextRequestTo;
-	setupRenderingTest(hooks);
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks, {
-		loggedInAs: "@testuser:localhost",
-		activeRealms: [baseRealm.url, testRealmURL],
-		autostart: true
-	});
-	hooks.beforeEach(async function() {
-		await setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				"colorish.gts": `
-          import StringField from '@cardstack/base/string';
-          export default class ColorishField extends StringField {
-            static displayName = 'Colorish';
-          }
-        `,
-				"theme.gts": `
-          import { contains, field, FieldDef } from '@cardstack/base/card-api';
-          import ColorishField from './colorish';
-          export class ThemeField extends FieldDef {
-            static displayName = 'Theme';
-            @field background = contains(ColorishField);
-            @field foreground = contains(ColorishField);
-            @field primary = contains(ColorishField);
-            @field secondary = contains(ColorishField);
-            @field accent = contains(ColorishField);
-            @field muted = contains(ColorishField);
-            @field border = contains(ColorishField);
-            @field ring = contains(ColorishField);
-          }
-        `,
-				"linked.gts": `
-          import { field, linksTo, linksToMany, CardDef } from '@cardstack/base/card-api';
-          export class Post extends CardDef {
-            static displayName = 'Post';
-            @field author = linksTo(() => Author);
-          }
-          export class Author extends CardDef {
-            static displayName = 'Author';
-            @field posts = linksToMany(() => Post);
-          }
-        `
-			}
-		});
-	});
-	hooks.beforeEach(function() {
-		let { virtualNetwork } = getService("network");
-		let inner = virtualNetwork.fetch;
-		virtualNetwork.fetch = (...args) => {
-			let [input] = args;
-			let url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-			requestLog.push(url);
-			let fail = failNextRequestTo;
-			if (fail && url.startsWith(fail)) {
-				failNextRequestTo = void 0;
-				return Promise.resolve(new Response("boom", {
-					status: 500,
-					statusText: "Server Error"
-				}));
-			}
-			return inner(...args);
-		};
-	});
-	hooks.afterEach(function() {
-		requestLog = [];
-		failNextRequestTo = void 0;
-	});
-	function requestsFor(prefix) {
-		return requestLog.filter((url) => url.startsWith(prefix));
-	}
-	function currentLoader() {
-		return getService("loader-service").loader;
-	}
-	async function importTheme() {
-		let { ThemeField } = await currentLoader().import(`${testRealmURL}theme`);
-		let cardTypeService = getService("card-type-service");
-		cardTypeService.invalidateAllCaches();
-		requestLog.length = 0;
-		return {
-			ThemeField,
-			cardTypeService
-		};
-	}
-	function hideLoaderModuleURLs() {
-		currentLoader().canonicalURLFor = () => void 0;
-	}
-	async function recorderIsLive() {
-		let sentinel = `${testRealmURL}__recorder-probe__`;
-		let before = requestLog.length;
-		await getService("network").virtualNetwork.fetch(sentinel).catch(() => void 0);
-		let saw = requestLog.slice(before).includes(sentinel);
-		requestLog.length = before;
-		return saw;
-	}
-	(0, import_qunit.test)("assembling a type reads the extension the loader already resolved, without asking the realm", async function(assert) {
-		let { ThemeField, cardTypeService } = await importTheme();
-		let type = await cardTypeService.assembleType(ThemeField);
-		assert.strictEqual(type.moduleInfo.extension, ".gts", "the extension was resolved");
-		assert.strictEqual(type.fields.length, COLORISH_FIELD_COUNT, "every field was assembled");
-		assert.deepEqual([...new Set(type.fields.map((f) => f.card.displayName))], ["Colorish"], "the fields all resolved to the shared field type");
-		assert.deepEqual(requestsFor(`${testRealmURL}colorish`), [], "the module the loader has already placed was not re-requested");
-		assert.deepEqual(requestLog.filter((url) => url.endsWith("/_info")), [], "nothing about an assembled type depends on realm info");
-		assert.true(await recorderIsLive(), "the recorder was still attached to the network under test");
-	});
-	(0, import_qunit.test)("the fields sharing a type resolve to one traversal between them", async function(assert) {
-		let { ThemeField, cardTypeService } = await importTheme();
-		let resolved = (await cardTypeService.assembleType(ThemeField)).fields.map((f) => f.card);
-		assert.strictEqual(new Set(resolved).size, 1, `all ${COLORISH_FIELD_COUNT} fields share one assembled type, rather than each building its own (got ${new Set(resolved).size} distinct)`);
-	});
-	(0, import_qunit.test)("the fallback fetches a shared module once for all the fields that share it", async function(assert) {
-		let { ThemeField, cardTypeService } = await importTheme();
-		hideLoaderModuleURLs();
-		let type = await cardTypeService.assembleType(ThemeField);
-		assert.strictEqual(type.moduleInfo.extension, ".gts", "the fallback resolved the extension");
-		let colorishRequests = requestsFor(`${testRealmURL}colorish`);
-		assert.strictEqual(colorishRequests.length, 1, `the shared field type's module was requested once, not once per field (got ${colorishRequests.length}: ${colorishRequests.join(", ")})`);
-	});
-	(0, import_qunit.test)("a failed fallback fetch is not cached, so the next assembly retries", async function(assert) {
-		let { ThemeField, cardTypeService } = await importTheme();
-		hideLoaderModuleURLs();
-		failNextRequestTo = `${testRealmURL}colorish`;
-		await assert.rejects(cardTypeService.assembleType(ThemeField), /status 500/, "the transient failure surfaces to the caller");
-		assert.strictEqual(failNextRequestTo, void 0, "the one-shot failure was actually served");
-		let type = await cardTypeService.assembleType(ThemeField);
-		assert.deepEqual([...new Set(type.fields.map((f) => f.card.displayName))], ["Colorish"], "the retry assembles the type it failed to assemble before");
-	});
-	(0, import_qunit.test)("concurrent roots in one module share a single fallback fetch for it", async function(assert) {
-		let { Post, Author } = await currentLoader().import(`${testRealmURL}linked`);
-		let cardTypeService = getService("card-type-service");
-		cardTypeService.invalidateAllCaches();
-		requestLog.length = 0;
-		hideLoaderModuleURLs();
-		await Promise.all([cardTypeService.assembleType(Post), cardTypeService.assembleType(Author)]);
-		let linkedRequests = requestsFor(`${testRealmURL}linked`);
-		assert.strictEqual(linkedRequests.length, 1, `both roots shared one fetch of their module (got ${linkedRequests.length}: ${linkedRequests.join(", ")})`);
-	});
-	(0, import_qunit.test)("mutually-referencing declarations in one module assemble concurrently", async function(assert) {
-		let { Post, Author } = await currentLoader().import(`${testRealmURL}linked`);
-		let cardTypeService = getService("card-type-service");
-		cardTypeService.invalidateAllCaches();
-		let [postType, authorType] = await Promise.all([cardTypeService.assembleType(Post), cardTypeService.assembleType(Author)]);
-		assert.strictEqual(postType.displayName, "Post", "the Post root settled");
-		assert.strictEqual(authorType.displayName, "Author", "the Author root settled");
-		assert.ok(postType.fields.some((f) => f.name === "author"), "the Post root resolved its link to Author");
-		assert.ok(authorType.fields.some((f) => f.name === "posts"), "the Author root resolved its link to Post");
-	});
-});
-//#endregion