@fougere/testing 0.6.0-alpha.0 → 0.8.0-alpha.0

package/src/stub.ts

@@ -8,18 +8,7 @@ export type Port = abstract new (...args: never[]) => unknown;
 /** The double handed in place of a port — one spy per method the port declares. */
 export type Stub<T> = { [K in keyof T]: T[K] extends (...args: never[]) => unknown ? Mock : T[K] };
 
-/**
- * The methods a port declares, read from the prototype chain at runtime.
- *
- * Not written by hand and not read from the AST: `ProviderEntry` keeps `ctor`, `deps` and
- * `filePath` and never the methods, while the prototype has them all along. So a double
- * carries exactly what the port carries and gains a method the day the port does — which
- * is the failure `ports.test.ts` records, a `charge is not a function` from a stand-in
- * that did not carry what its type promised.
- *
- * Walks the chain because a port may itself extend one; stops at `Object.prototype`,
- * whose members belong to no port.
- */
+/** The methods a port declares, read from the prototype chain at runtime. */
 export function methodsOf(port: Port): string[] {
   const found = new Set<string>();
   let proto: object | null = port.prototype as object;
@@ -34,32 +23,14 @@ export function methodsOf(port: Port): string[] {
   return [...found];
 }
 
-/**
- * A double for a port: every method present, every call recorded, nothing returned.
- *
- * What it RETURNS is not derivable and the value is the caller's to state — a service's
- * return type is a bare TypeScript type, erased at runtime, with no declared fields for
- * anything to build from. The same line the whole package sits on: what Fougere's
- * vocabulary declares can be derived, arbitrary code cannot.
- */
+/** A double for a port. */
 export function stubOf<T>(port: Port): Stub<T> {
   const double: Record<string, Mock> = {};
   for (const method of methodsOf(port)) double[method] = vi.fn();
   return double as Stub<T>;
 }
 
-/**
- * Put doubles in front of ports, in every frond scope that answers under their name.
- *
- * After the boot rather than through `ports:`, because the container resolves lazily: a
- * provider is built on first `resolve`, so a value registered before any call is the one
- * a handler receives. `registerValue` also marks it as not the container's to dispose,
- * which is right — the test made it.
- *
- * A port nobody answers under is REFUSED by name, for the reason `ports:` refuses a key
- * that matched nothing: a double that silently stands in front of no one reads as a test
- * that covered a case it never reached.
- */
+/** Put doubles in front of ports, in every frond scope that answers under their name. */
 export function installStubs(app: App, ports: Port[]): Map<Port, Stub<unknown>> {
   const doubles = new Map<Port, Stub<unknown>>();
   const scopes = app.fronds.map((frond) => app.resolve<Container>(`frond:${frond.name}`));

package/src/sync.ts

@@ -33,28 +33,18 @@ export async function syncedRemotes(root: string): Promise<SyncedRemote[]> {
   }
 }
 
-/**
- * The shapes a consumer holds for one remote frond.
- *
- * Rebuilt from the classes rather than read back: `fougere sync` writes entities and an
- * index and does NOT keep the card it received. So the consumer's copy of the OPERATIONS
- * has no local counterpart at all, and only the shapes can be compared — which is the
- * narrower half, and the one that breaks a caller silently.
- *
- * Closing that would mean `sync` writing the card beside the classes; it is a change to
- * the CLI, not to this file.
- */
+/** The shapes a consumer holds for one remote frond. */
 export async function heldShapes(remote: SyncedRemote): Promise<Map<string, SchemaDescriptor>> {
-  const held = new Map<string, SchemaDescriptor>();
+  const cards = new Map<string, SchemaDescriptor>();
   const index = pathToFileURL(join(remote.path, 'index.ts')).href;
   const module = await import(index) as Record<string, unknown>;
 
   for (const [name, exported] of Object.entries(module)) {
     const entity = exported as SchemaView | undefined;
     if (typeof entity !== 'function' || typeof (entity as SchemaView).getFields !== 'function') continue;
-    held.set(name, Card.fromSchema(entity).descriptor);
+    cards.set(name, Card.fromSchema(entity).descriptor);
   }
-  return held;
+  return cards;
 }
 
 /** The shapes a card announces, by the name a door carries. */
@@ -67,14 +57,7 @@ function servedShapes(card: IdentityCard, frond: string): Map<string, unknown> {
   return served;
 }
 
-/**
- * What the consumer's copy no longer matches.
- *
- * Compared by the shape's own `title` — the entity's name as the descriptor carries it —
- * rather than by the door's, because a door is addressed in lowercase (`post`) and a class
- * is not (`Post`), and matching those two by hand is where a name convention gets copied
- * a third time.
- */
+/** What the consumer's copy no longer matches. */
 export function syncDriftOf(
   held: Map<string, SchemaDescriptor>,
   card: IdentityCard,

package/src/vitest.ts

@@ -1,25 +1,6 @@
 import { createRequire } from 'node:module';
 
-/**
- * The vitest configuration a Fougere project needs, so nobody has to discover it.
- *
- * One thing to know, and it is not obvious: `graphql` guards its types with `instanceOf`,
- * so a schema built by one loaded copy is refused by another with *"from another module
- * or realm"*. Under vitest a module is either transformed by Vite or externalized and
- * loaded by node, and Pothos ending up on one side while `graphql()` sits on the other
- * makes two copies of the same file. The alias pins the path, and the inlining makes the
- * packages that touch it take that path — neither alone is enough, which is what made
- * this cost an afternoon.
- *
- * An app that serves no GraphQL pays nothing for this: the alias resolves to whatever
- * `graphql` the project has, and no `graphql` means the option is simply unused.
- *
- * ```ts
- * // vitest.config.ts
- * import { fougereTest } from '@fougere/testing/vitest';
- * export default fougereTest();
- * ```
- */
+/** The vitest configuration a Fougere project needs, so nobody has to discover it. */
 export function fougereTest(overrides: Record<string, unknown> = {}): Record<string, unknown> {
   const require = createRequire(import.meta.url);
   let graphqlDir: string | undefined;