@alloy-js/core 0.19.0-dev.2 → 0.19.0

package/test/components/append-file.test.tsx

@@ -0,0 +1,275 @@
+import { existsSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { AppendFile, AppendRegion } from "../../src/components/AppendFile.jsx";
+import { render, renderAsync } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+
+describe("AppendFile", () => {
+  let testFilePath: string;
+
+  beforeEach(() => {
+    // Create a unique temporary file path for each test
+    testFilePath = join(tmpdir(), `test-append-file-${Date.now()}.txt`);
+  });
+
+  afterEach(() => {
+    // Clean up test file after each test
+    if (existsSync(testFilePath)) {
+      unlinkSync(testFilePath);
+    }
+  });
+
+  it("should append content to end of file when no sigils present", async () => {
+    // Create initial file content
+    writeFileSync(testFilePath, "Initial content", "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath}>
+        <AppendRegion id="append">New content</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync("Initial content\nNew content");
+  });
+  it("should append content to end of file when no sigils present with no explicit append region", async () => {
+    // Create initial file content
+    writeFileSync(testFilePath, "Initial content", "utf-8");
+
+    const result = <AppendFile path={testFilePath}>New content</AppendFile>;
+
+    await expect(result).toRenderToAsync("Initial content\nNew content");
+  });
+
+  it("should append content within region sigils", async () => {
+    const initialContent = d`
+      Header content
+      <!-- alloy-main-start -->
+      <!-- alloy-main-end -->
+      Footer content
+    `;
+
+    writeFileSync(testFilePath, initialContent, "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["main"]}>
+        <AppendRegion id="main">New main content</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      Header content
+      <!-- alloy-main-start -->
+      New main content
+      <!-- alloy-main-end -->
+      Footer content
+    `);
+  });
+
+  it("should handle multiple regions", async () => {
+    const initialContent = d`
+      <!-- alloy-header-start -->
+      <!-- alloy-header-end -->
+      Main content
+      <!-- alloy-footer-start -->
+      <!-- alloy-footer-end -->
+    `;
+
+    writeFileSync(testFilePath, initialContent, "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["header", "footer"]}>
+        <AppendRegion id="header">Header text</AppendRegion>
+        <AppendRegion id="footer">Footer text</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      <!-- alloy-header-start -->
+      Header text
+      <!-- alloy-header-end -->
+      Main content
+      <!-- alloy-footer-start -->
+      Footer text
+      <!-- alloy-footer-end -->
+    `);
+  });
+
+  it("should preserve existing content and append new content", async () => {
+    const initialContent = d`
+      Header
+      <!-- alloy-main-start -->
+      Existing content
+      <!-- alloy-main-end -->
+      Footer
+    `;
+
+    writeFileSync(testFilePath, initialContent, "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["main"]}>
+        <AppendRegion id="main">New appended content</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      Header
+      <!-- alloy-main-start -->
+      Existing content
+      New appended content
+      <!-- alloy-main-end -->
+      Footer
+    `);
+  });
+
+  it("should use content prop instead of children", async () => {
+    writeFileSync(testFilePath, "Start ", "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath}>
+        <AppendRegion id="append" content="End" />
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync("Start\nEnd");
+  });
+
+  it("should default to 'append' region when no regions specified", async () => {
+    writeFileSync(testFilePath, "Content", "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath}>
+        <AppendRegion id="append">default region</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync("Content\ndefault region");
+  });
+
+  it("should throw error when region is missing corresponding AppendRegion", async () => {
+    writeFileSync(testFilePath, "content", "utf-8");
+
+    expect(() =>
+      render(
+        <AppendFile path={testFilePath} regions={["missing"]}>
+          <AppendRegion id="append">content</AppendRegion>
+        </AppendFile>,
+      ),
+    ).toThrow(
+      'Region "missing" specified but no corresponding AppendRegion child found',
+    );
+  });
+
+  it("should throw error when AppendRegion has neither children nor content", async () => {
+    writeFileSync(testFilePath, "content", "utf-8");
+
+    expect(() =>
+      render(
+        <AppendFile path={testFilePath}>
+          <AppendRegion id="append" />
+        </AppendFile>,
+      ),
+    ).toThrow('AppendRegion "append" must have either children or content');
+  });
+
+  it("should throw error when region has missing start sigil", async () => {
+    const contentWithOnlyEnd = d`
+      Content
+      <!-- alloy-incomplete-end -->
+    `;
+
+    writeFileSync(testFilePath, contentWithOnlyEnd, "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["incomplete"]}>
+        <AppendRegion id="incomplete">content</AppendRegion>
+      </AppendFile>
+    );
+
+    // Should insert before the end sigil
+    await expect(result).toRenderToAsync(d`
+      Content
+      content
+      <!-- alloy-incomplete-end -->
+    `);
+  });
+
+  it("should throw error when region has missing end sigil", async () => {
+    const contentWithOnlyStart = d`
+      Content
+      <!-- alloy-incomplete-start -->
+    `;
+
+    writeFileSync(testFilePath, contentWithOnlyStart, "utf-8");
+
+    await expect(async () =>
+      renderAsync(
+        <AppendFile path={testFilePath} regions={["incomplete"]}>
+          <AppendRegion id="incomplete">content</AppendRegion>
+        </AppendFile>,
+      ),
+    ).rejects.toThrow(
+      'Region "incomplete" has start sigil but no corresponding end sigil',
+    );
+  });
+
+  it("should handle complex nested content", async () => {
+    const initialContent = d`
+      <!-- alloy-config-start -->
+      <!-- alloy-config-end -->
+    `;
+
+    writeFileSync(testFilePath, initialContent, "utf-8");
+
+    const jsonContent = d`
+      {
+        "newProperty": "value",
+        "nested": {
+          "key": "data"
+        }
+      }
+    `;
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["config"]}>
+        <AppendRegion id="config">{jsonContent}</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      <!-- alloy-config-start -->
+      {
+        "newProperty": "value",
+        "nested": {
+          "key": "data"
+        }
+      }
+      <!-- alloy-config-end -->
+    `);
+  });
+
+  it("should preserve indentation level of the end sigil", async () => {
+    const initialContent = d`
+      base
+        <!-- alloy-indented-start -->
+        <!-- alloy-indented-end -->
+    `;
+
+    writeFileSync(testFilePath, initialContent, "utf-8");
+
+    const result = (
+      <AppendFile path={testFilePath} regions={["indented"]}>
+        <AppendRegion id="indented">new content</AppendRegion>
+      </AppendFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      base
+        <!-- alloy-indented-start -->
+        new content
+        <!-- alloy-indented-end -->
+    `);
+  });
+});

package/test/components/copy-file.test.tsx

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CopyFile } from "../../src/components/CopyFile.jsx";
+import { SourceDirectory } from "../../src/components/SourceDirectory.jsx";
+import { CopyOutputFile, render } from "../../src/render.js";
+import { writeOutput } from "../../src/write-output.js";
+import "../../testing/extend-expect.js";
+
+describe("CopyFile", () => {
+  let testDir: string;
+  let sourceFile: string;
+  let targetFile: string;
+
+  beforeEach(() => {
+    // Create unique temporary paths for each test
+    testDir = tmpdir();
+    sourceFile = join(testDir, "source.txt");
+    targetFile = join(testDir, "target.txt");
+  });
+
+  afterEach(() => {
+    // Clean up test files after each test
+    if (existsSync(sourceFile)) {
+      unlinkSync(sourceFile);
+    }
+    if (existsSync(targetFile)) {
+      unlinkSync(targetFile);
+    }
+  });
+
+  it("should create copy file context with correct paths", async () => {
+    writeFileSync(sourceFile, "Hello, World!", "utf-8");
+
+    const result = (
+      <SourceDirectory path={testDir}>
+        <CopyFile src={sourceFile} path="target.txt" />
+      </SourceDirectory>
+    );
+
+    const output = render(result);
+    await writeOutput(output);
+
+    expect(output.contents).toHaveLength(1);
+    const copyFileOutput = output.contents[0] as CopyOutputFile;
+    expect(copyFileOutput.kind).toBe("file");
+    expect(copyFileOutput.sourcePath).toBe(sourceFile);
+    expect(copyFileOutput.path).toBe(join(testDir, "target.txt"));
+    expect(existsSync(targetFile)).toBe(true);
+    const targetContent = readFileSync(targetFile, "utf-8");
+    expect(targetContent).toBe("Hello, World!");
+  });
+
+  it("should handle relative paths correctly", async () => {
+    // Create source file
+    writeFileSync(sourceFile, "Relative path test", "utf-8");
+
+    const result = (
+      <SourceDirectory path={testDir}>
+        <SourceDirectory path="subdir">
+          <CopyFile src={sourceFile} path="nested-target.txt" />
+        </SourceDirectory>
+      </SourceDirectory>
+    );
+
+    const output = render(result);
+
+    // Find the copy file in the nested directory
+    const subdir = output.contents.find(
+      (item) =>
+        item.kind === "directory" && item.path === join(testDir, "subdir"),
+    );
+    expect(subdir).toBeDefined();
+
+    if (subdir && subdir.kind === "directory") {
+      expect(subdir.contents).toHaveLength(1);
+      const copyFile = subdir.contents[0];
+      expect(copyFile.kind).toBe("file");
+
+      if (copyFile.kind === "file" && "sourcePath" in copyFile) {
+        expect(copyFile.sourcePath).toBe(sourceFile);
+        expect(copyFile.path).toBe(
+          join(testDir, "subdir", "nested-target.txt"),
+        );
+      }
+    }
+  });
+
+  it("should throw error when used without SourceDirectory context", () => {
+    // Create source file
+    writeFileSync(sourceFile, "Error test", "utf-8");
+
+    expect(() => {
+      render(<CopyFile src={sourceFile} path="target.txt" />);
+    }).toThrow("Copy file doesn't have parent directory");
+  });
+});

package/test/components/source-file.test.tsx

@@ -1,5 +1,6 @@
 import {
   computed,
+  ContentOutputFile,
   Output,
   render,
   renderTree,
@@ -50,7 +51,9 @@ it("has reactive context", () => {
     </Output>,
   );
 
-  expect(tree.contents[1].contents).toEqual("hi.txt contents.txt");
+  expect((tree.contents[1] as ContentOutputFile).contents).toEqual(
+    "hi.txt contents.txt",
+  );
 });
 
 it("Includes header", () => {
@@ -63,7 +66,7 @@ it("Includes header", () => {
     </Output>,
   );
 
-  expect(tree.contents[0].contents).toEqual(d`
+  expect((tree.contents[0] as ContentOutputFile).contents).toEqual(d`
     # This is a header
     hello!
     `);

package/test/components/template-file.test.tsx

@@ -0,0 +1,127 @@
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { describe, expect, it } from "vitest";
+import {
+  TemplateFile,
+  TemplateVariable,
+} from "../../src/components/TemplateFile.jsx";
+import { renderAsync } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+
+describe("TemplateFile", () => {
+  it("should replace template variables with values", async () => {
+    // Create a temporary template file
+    const templatePath = join(tmpdir(), "test-template.txt");
+    const templateContent = "Hello {{ name }}! You are {{ age }} years old.";
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt">
+        <TemplateVariable name="name" value="John" />
+        <TemplateVariable name="age" value="25" />
+      </TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync("Hello John! You are 25 years old.");
+  });
+
+  it("should handle template variables with children", async () => {
+    const templatePath = join(tmpdir(), "test-template-children.txt");
+    const templateContent = "Welcome {{ greeting }}!";
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt">
+        <TemplateVariable name="greeting">Hello World</TemplateVariable>
+      </TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync("Welcome Hello World!");
+  });
+
+  it("should handle complex templates with multiple variables", async () => {
+    const templatePath = join(tmpdir(), "test-complex-template.txt");
+    const templateContent = d`
+      Name: {{ name }}
+      Age: {{ age }}
+      Location: {{ location }}
+      Status: {{ status }}
+    `;
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt">
+        <TemplateVariable name="name" value="Alice" />
+        <TemplateVariable name="age">30</TemplateVariable>
+        <TemplateVariable name="location" value="New York" />
+        <TemplateVariable name="status" value="Active" />
+      </TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync(d`
+      Name: Alice
+      Age: 30
+      Location: New York
+      Status: Active
+    `);
+  });
+
+  it("should handle templates with whitespace around variable names", async () => {
+    const templatePath = join(tmpdir(), "test-whitespace-template.txt");
+    const templateContent = "Hello {{  name  }}!";
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt">
+        <TemplateVariable name="name" value="Bob" />
+      </TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync("Hello Bob!");
+  });
+
+  it("should throw error for missing template variables", async () => {
+    const templatePath = join(tmpdir(), "test-missing-var-template.txt");
+    const templateContent = "Hello {{ name }}! Your age is {{ age }}.";
+    writeFileSync(templatePath, templateContent);
+
+    await expect(
+      async () =>
+        await renderAsync(
+          <TemplateFile src={templatePath} path="output.txt">
+            <TemplateVariable name="name" value="Charlie" />
+          </TemplateFile>,
+        ),
+    ).rejects.toThrow(
+      'Template variable "age" not found in TemplateVariable children',
+    );
+  });
+
+  it("should handle template with no variables", async () => {
+    const templatePath = join(tmpdir(), "test-no-vars-template.txt");
+    const templateContent = "This is just plain text with no variables.";
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt"></TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync(
+      "This is just plain text with no variables.",
+    );
+  });
+
+  it("should handle empty template", async () => {
+    const templatePath = join(tmpdir(), "test-empty-template.txt");
+    const templateContent = "";
+    writeFileSync(templatePath, templateContent);
+
+    const result = (
+      <TemplateFile src={templatePath} path="output.txt"></TemplateFile>
+    );
+
+    await expect(result).toRenderToAsync("");
+  });
+});