@alloy-js/core 0.18.0-dev.5 → 0.18.1

package/test/components/slot.test.tsx

@@ -51,7 +51,7 @@ it("works with string keys", () => {
     );
   });
 
-  const tree = render(
+  const _tree = render(
     <Output>
       <SourceFile path="test.ts" filetype="ts">
         <MyFunctionComponent name="foo" />
@@ -59,7 +59,7 @@ it("works with string keys", () => {
     </Output>,
   );
 
-  console.log(tree.contents[0].contents);
+  // console.log(tree.contents[0].contents);
 });
 
 it("works with symbols", () => {
@@ -79,7 +79,6 @@ it("works with symbols", () => {
   }
 
   function MyFunctionComponent(props: FunctionComponentProps) {
-    const binder = useBinder();
     const sym = new OutputSymbol(props.name, {
       refkeys: refkey(),
     });
@@ -108,7 +107,7 @@ it("works with symbols", () => {
     );
   });
 
-  const tree = render(
+  const _tree = render(
     <Output>
       <SourceFile path="test.ts" filetype="ts">
         <Scope name="foo">
@@ -118,7 +117,7 @@ it("works with symbols", () => {
     </Output>,
   );
 
-  console.log(tree.contents[0].contents);
+  // console.log(tree.contents[0].contents);
 });
 
 it("can rename", () => {
@@ -161,7 +160,7 @@ it("can rename", () => {
     return binder!.resolveFQN("foo.bar") as Ref<OutputSymbol | undefined>;
   }, "bazxxx");
 
-  const tree = render(
+  const _tree = render(
     <Output>
       <SourceFile path="test.ts" filetype="ts">
         <Scope name="foo">
@@ -171,5 +170,5 @@ it("can rename", () => {
     </Output>,
   );
 
-  console.log(tree.contents[0].contents);
+  // console.log(tree.contents[0].contents);
 });

package/testing/extend-expect.test.tsx

@@ -0,0 +1,126 @@
+import { Indent, Output, SourceDirectory, SourceFile } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import "./extend-expect.js";
+
+describe("toRenderTo", () => {
+  it("can validate structure without source files", () => {
+    expect(
+      <>
+        base
+        <Indent>indented</Indent>
+      </>,
+    ).toRenderTo(`
+      base
+        indented
+      `);
+  });
+
+  it("can expect the content of the single source file used", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo(`
+        base
+            indented
+        `);
+  });
+
+  it("expect with specific file name", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo({
+      "Test.cs": `
+        base
+            indented
+        `,
+    });
+  });
+
+  it("expect with specific file name in SourceDirectory", () => {
+    expect(
+      <Output>
+        <SourceDirectory path="src">
+          <SourceFile path="test.txt" filetype="text">
+            content
+          </SourceFile>
+        </SourceDirectory>
+      </Output>,
+    ).toRenderTo({
+      "src/test.txt": `
+          content
+        `,
+    });
+  });
+
+  it("each source file respect their print options", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base1
+          <Indent>indented</Indent>
+        </SourceFile>
+        <SourceFile path="Test.ts" tabWidth={2} filetype="csharp">
+          base2
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo({
+      "Test.cs": `
+        base1
+            indented
+        `,
+      "Test.ts": `
+        base2
+          indented
+        `,
+    });
+  });
+
+  it("fails when content does not match", () => {
+    expect(() =>
+      expect(
+        <>
+          base
+          <Indent>indented</Indent>
+        </>,
+      ).toRenderTo(`
+      base
+        wrong
+    `),
+    ).toThrowError(/Render is incorrect/);
+  });
+
+  it("fails when files don't match", () => {
+    expect(() =>
+      expect(
+        <Output>
+          <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+            base1
+            <Indent>indented</Indent>
+          </SourceFile>
+          <SourceFile path="Test.ts" tabWidth={2} filetype="typescript">
+            base2
+            <Indent>indented</Indent>
+          </SourceFile>
+        </Output>,
+      ).toRenderTo({
+        "Test.cs": `
+        bad
+        `,
+        "Test.ts": `
+        base2
+          indented
+        `,
+      }),
+    ).toThrowError(/Render is incorrect/);
+  });
+});

package/testing/extend-expect.ts

@@ -1,6 +1,14 @@
-import { Children, printTree, renderTree } from "@alloy-js/core";
+import {
+  Children,
+  getContextForRenderNode,
+  printTree,
+  RenderedTextTree,
+  renderTree,
+} from "@alloy-js/core";
+import "vitest";
 import { expect } from "vitest";
 import { dedent } from "./render.js";
+import "./vitest.d.ts";
 
 interface ToRenderToOptions {
   printWidth?: number;
@@ -11,36 +19,113 @@ interface ToRenderToOptions {
 expect.extend({
   toRenderTo(
     received: Children,
-    expectedRaw: string,
+    expectedRaw: string | Record<string, string>,
     renderOptions?: ToRenderToOptions,
   ) {
+    const message = () => `Render is${isNot ? " not" : ""} incorrect`;
+
     const { isNot } = this;
-    const tree = renderTree(received);
-    const actual = printTree(tree, renderOptions);
-    const expected = dedent(expectedRaw);
-    return {
-      pass: actual === expected,
-      message: () => {
-        return `Render is${isNot ? " not" : ""} incorrect`;
-      },
-      actual,
-      expected,
-    };
+    const actual = renderAsFiles(received, renderOptions);
+    if (typeof expectedRaw === "string") {
+      const expected = dedent(expectedRaw);
+      let actualStr;
+      if (typeof actual === "string") {
+        actualStr = actual;
+      } else if (Object.keys(actual).length === 1) {
+        // If we have a single file, we can use its content directly.
+        actualStr = Object.values(actual)[0];
+      } else {
+        return {
+          pass: false,
+          message,
+          actual,
+          expected,
+        };
+      }
+      return {
+        pass: actualStr === expected,
+        message,
+        actual: actualStr,
+        expected,
+      };
+    } else if (typeof actual === "object" && typeof expectedRaw === "object") {
+      const expected = expectedRaw;
+      const dedentExpected: Record<string, string> = {};
+      for (const [key, value] of Object.entries(expected)) {
+        dedentExpected[key] = dedent(value);
+      }
+      const pass =
+        Object.keys(actual).length === Object.keys(expected).length &&
+        Object.entries(actual).every(([key, value]) => {
+          return dedentExpected[key] === value;
+        });
+      return {
+        pass,
+        message,
+        actual,
+        expected: dedentExpected,
+      };
+    } else {
+      return {
+        pass: false,
+        message,
+        actual,
+        expected: expectedRaw,
+      };
+    }
   },
 });
 
-import "vitest";
+function renderAsFiles(
+  received: Children,
+  options?: ToRenderToOptions,
+): Record<string, string> | string {
+  const files: Record<string, string> = {};
+  const tree = renderTree(received);
 
-interface ToRenderToRenderOptions {
-  printWidth?: number;
-  tabWidth?: number;
-  useTabs?: boolean;
-}
-interface CustomMatchers<R = unknown> {
-  toRenderTo: (str: string, options?: ToRenderToRenderOptions) => R;
-}
+  // when passing Output, the first render tree child is the Output component.
+  const rootRenderOptions =
+    Array.isArray(tree) ?
+      (getContextForRenderNode(tree[0] as RenderedTextTree)?.meta
+        ?.printOptions ?? {})
+    : {};
+
+  collectSourceFiles(tree);
+  function collectSourceFiles(root: RenderedTextTree) {
+    if (!Array.isArray(root)) {
+      return;
+    }
+    const context = getContextForRenderNode(root);
+    if (context?.meta?.sourceFile) {
+      files[context.meta.sourceFile.path] = printTree(root, {
+        printWidth:
+          options?.printWidth ??
+          context.meta?.printOptions?.printWidth ??
+          rootRenderOptions.printWidth,
+        tabWidth:
+          options?.tabWidth ??
+          context.meta?.printOptions?.tabWidth ??
+          rootRenderOptions.tabWidth,
+        useTabs:
+          options?.useTabs ??
+          context.meta?.printOptions?.useTabs ??
+          rootRenderOptions.useTabs,
+      });
+    } else {
+      visitChildren();
+    }
+
+    function visitChildren() {
+      for (const child of root) {
+        collectSourceFiles(child as RenderedTextTree);
+      }
+    }
+  }
 
-declare module "vitest" {
-  interface Assertion<T = any> extends CustomMatchers<T> {}
-  interface AsymmetricMatchersContaining extends CustomMatchers {}
+  // If we found no source files, we return the tree as a string.
+  if (Object.keys(files).length === 0) {
+    return printTree(tree, options);
+  } else {
+    return files;
+  }
 }

package/testing/vitest.d.ts

@@ -5,8 +5,12 @@ interface ToRenderToRenderOptions {
   tabWidth?: number;
   useTabs?: boolean;
 }
+
 interface CustomMatchers<R = unknown> {
-  toRenderTo: (str: string, options?: ToRenderToRenderOptions) => R;
+  toRenderTo: (
+    str: string | Record<string, string>,
+    options?: ToRenderToRenderOptions,
+  ) => R;
 }
 
 declare module "vitest" {

package/tsconfig.json

@@ -11,7 +11,8 @@
     "test/**/*.ts",
     "test/**/*.tsx",
     "testing/**/*.ts",
-    "testing/**/*.d.ts"
+    "testing/**/*.d.ts",
+    "testing/extend-expect.test.tsx"
   ],
   "exclude": ["node_modules", "dist"]
 }