@simplysm/sd-cli 13.0.100 → 14.0.1

package/tests/utils/package-utils.spec.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { validateTargets } from "../../src/utils/package-utils";
+
+describe("validateTargets", () => {
+  const packages = {
+    "core-node": { target: "node" },
+    "core-common": { target: "neutral" },
+    "storage": { target: "node" },
+  };
+
+  it("does nothing when targets is empty", () => {
+    expect(() => validateTargets([], packages)).not.toThrow();
+  });
+
+  it("does nothing when all targets exist in packages", () => {
+    expect(() => validateTargets(["core-node", "storage"], packages)).not.toThrow();
+  });
+
+  it("throws SdError for a single unknown target", () => {
+    expect(() => validateTargets(["nonexistent"], packages)).toThrow(
+      "Unknown target: nonexistent",
+    );
+  });
+
+  it("throws SdError listing all unknown targets", () => {
+    expect(() => validateTargets(["bad1", "bad2"], packages)).toThrow(
+      "Unknown target: bad1, bad2",
+    );
+  });
+
+  it("throws SdError when some targets are valid and some are not", () => {
+    expect(() => validateTargets(["core-node", "nonexistent"], packages)).toThrow(
+      "Unknown target: nonexistent",
+    );
+  });
+
+  it("does not throw for packages with undefined config", () => {
+    const packagesWithUndefined = {
+      "core-node": { target: "node" },
+      "empty-pkg": undefined,
+    };
+    expect(() => validateTargets(["core-node"], packagesWithUndefined)).not.toThrow();
+  });
+
+  it("allows targeting a package with undefined config", () => {
+    const packagesWithUndefined: Record<string, unknown> = {
+      "core-node": { target: "node" },
+      "empty-pkg": undefined,
+    };
+    expect(() => validateTargets(["empty-pkg"], packagesWithUndefined)).not.toThrow();
+  });
+});

package/tests/utils/rebuild-manager.spec.ts

@@ -1,43 +1,46 @@
 import { describe, it, expect, vi } from "vitest";
-import { consola } from "consola";
 import { RebuildManager } from "../../src/utils/rebuild-manager";
 
-describe("RebuildManager", () => {
-  it("logs start/success messages on rebuild batch", async () => {
-    const logger = consola.withTag("test");
-    const startSpy = vi.spyOn(logger, "start");
-    const successSpy = vi.spyOn(logger, "success");
+function createManager() {
+  const logger = { start: vi.fn(), success: vi.fn(), error: vi.fn() };
+  const manager = new RebuildManager(logger as any);
+  return { manager, logger };
+}
 
-    const manager = new RebuildManager(logger);
+describe("RebuildManager", () => {
+  it("batches concurrent builds into single batchComplete event", async () => {
+    const { manager } = createManager();
+    const batchComplete = vi.fn();
+    manager.on("batchComplete", batchComplete);
 
-    const resolver = manager.registerBuild("pkg1:build", "pkg1 (node)");
+    const resolverA = manager.registerBuild("a", "Build A");
+    const resolverB = manager.registerBuild("b", "Build B");
 
-    // resolve to complete the build
-    resolver();
+    // Resolve both builds
+    resolverA();
+    resolverB();
 
-    // wait for _runBatch microtask + Promise.allSettled
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    // Wait for batch to process (microtask)
+    await new Promise((r) => setTimeout(r, 50));
 
-    expect(startSpy).toHaveBeenCalledWith("Rebuilding... (pkg1 (node))");
-    expect(successSpy).toHaveBeenCalledWith("Rebuild completed (pkg1 (node))");
+    expect(batchComplete).toHaveBeenCalledOnce();
   });
 
-  it("batches multiple builds and logs them together", async () => {
-    const logger = consola.withTag("test");
-    const startSpy = vi.spyOn(logger, "start");
-    const successSpy = vi.spyOn(logger, "success");
-
-    const manager = new RebuildManager(logger);
+  it("runs new batch when builds registered during processing", async () => {
+    const { manager } = createManager();
+    const batchComplete = vi.fn();
+    manager.on("batchComplete", batchComplete);
 
-    const resolver1 = manager.registerBuild("pkg1:build", "pkg1 (node)");
-    const resolver2 = manager.registerBuild("pkg2:build", "pkg2 (browser)");
+    const resolverA = manager.registerBuild("a", "Build A");
+    resolverA();
 
-    resolver1();
-    resolver2();
+    // Wait for first batch to start, then register new build
+    await new Promise((r) => setTimeout(r, 10));
+    const resolverB = manager.registerBuild("b", "Build B");
+    resolverB();
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((r) => setTimeout(r, 100));
 
-    expect(startSpy).toHaveBeenCalledWith("Rebuilding... (pkg1 (node), pkg2 (browser))");
-    expect(successSpy).toHaveBeenCalledWith("Rebuild completed (pkg1 (node), pkg2 (browser))");
+    expect(batchComplete).toHaveBeenCalledTimes(2);
   });
 });

package/tests/utils/replace-deps.spec.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest";
+import { resolveReplaceDepEntries, parseWorkspaceGlobs } from "../../src/utils/replace-deps";
+
+describe("resolveReplaceDepEntries", () => {
+  it("matches exact package names", () => {
+    const results = resolveReplaceDepEntries(
+      { "@simplysm/core-common": "../core-common" },
+      ["@simplysm/core-common", "@simplysm/core-node"],
+    );
+
+    expect(results).toHaveLength(1);
+    expect(results[0].targetName).toBe("@simplysm/core-common");
+    expect(results[0].sourcePath).toBe("../core-common");
+  });
+
+  it("matches glob patterns with wildcard", () => {
+    const results = resolveReplaceDepEntries(
+      { "@simplysm/*": "../packages/*" },
+      ["@simplysm/core-common", "@simplysm/core-node"],
+    );
+
+    expect(results).toHaveLength(2);
+    expect(results[0].sourcePath).toBe("../packages/core-common");
+    expect(results[1].sourcePath).toBe("../packages/core-node");
+  });
+
+  it("returns empty array when no matches", () => {
+    const results = resolveReplaceDepEntries(
+      { "@other/*": "../other/*" },
+      ["@simplysm/core-common"],
+    );
+
+    expect(results).toHaveLength(0);
+  });
+});
+
+describe("parseWorkspaceGlobs", () => {
+  it("parses packages section from workspace yaml", () => {
+    const content = `packages:
+  - "packages/*"
+  - "tools/*"
+`;
+    const globs = parseWorkspaceGlobs(content);
+    expect(globs).toEqual(["packages/*", "tools/*"]);
+  });
+
+  it("handles unquoted values", () => {
+    const content = `packages:
+  - packages/*
+`;
+    const globs = parseWorkspaceGlobs(content);
+    expect(globs).toEqual(["packages/*"]);
+  });
+
+  it("stops at next section", () => {
+    const content = `packages:
+  - packages/*
+other:
+  - something
+`;
+    const globs = parseWorkspaceGlobs(content);
+    expect(globs).toEqual(["packages/*"]);
+  });
+
+  it("returns empty array when no packages section", () => {
+    const globs = parseWorkspaceGlobs("other:\n  - foo\n");
+    expect(globs).toEqual([]);
+  });
+});

package/tests/utils/scss-compiler.spec.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { resolve } from "node:path";
+import fs from "node:fs";
+import { compileScssString, compileScssFile } from "../../src/utils/scss-compiler";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../..");
+const angularPkgDir = resolve(workspaceRoot, "packages/angular");
+
+// Temp directory for node_modules @use test
+const tmpDir = resolve(import.meta.dirname, "__scss_test_tmp__");
+
+describe("scss-compiler", () => {
+  beforeAll(() => {
+    // Create a temp node_modules-like structure for package @use test
+    const fakeNmDir = resolve(tmpDir, "node_modules/@simplysm/angular/scss/commons");
+    fs.mkdirSync(fakeNmDir, { recursive: true });
+    fs.writeFileSync(
+      resolve(fakeNmDir, "_variables.scss"),
+      "$test-var: red;\n",
+    );
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("compileScssString", () => {
+    it("compiles inline SCSS with variable to CSS", () => {
+      const source = "$color: blue;\n.header { color: $color; }";
+      const containingFile = resolve(angularPkgDir, "src/fake-component.ts");
+      const loadPaths = [
+        resolve(angularPkgDir, "scss"),
+        resolve(workspaceRoot, "node_modules"),
+      ];
+
+      const result = compileScssString(source, containingFile, loadPaths);
+
+      expect(result.css).toContain(".header");
+      expect(result.css).toContain("color: blue");
+      expect(result.dependencies).toBeDefined();
+    });
+
+    // Acceptance: Scenario "순수 CSS 인라인 스타일은 변환 없이 통과한다"
+    it("passes through pure CSS without modification", () => {
+      const source = ".header { color: blue; }";
+      const containingFile = resolve(angularPkgDir, "src/fake-component.ts");
+      const loadPaths: string[] = [];
+
+      const result = compileScssString(source, containingFile, loadPaths);
+
+      expect(result.css).toContain(".header");
+      expect(result.css).toContain("color: blue");
+    });
+
+    // Acceptance: Scenario "인라인 SCSS 구문 에러 시 diagnostics에 에러가 포함된다"
+    it("throws on SCSS syntax error", () => {
+      const source = ".header { color: $undefined-var; }";
+      const containingFile = resolve(angularPkgDir, "src/fake-component.ts");
+      const loadPaths: string[] = [];
+
+      expect(() => compileScssString(source, containingFile, loadPaths)).toThrow();
+    });
+
+    // Acceptance: Scenario "같은 패키지 내 상대 경로 @use를 해석한다"
+    it("resolves relative @use paths within the package", () => {
+      const source = '@use "commons/variables";\n.test { display: block; }';
+      const containingFile = resolve(angularPkgDir, "src/fake-component.ts");
+      const loadPaths = [resolve(angularPkgDir, "scss")];
+
+      const result = compileScssString(source, containingFile, loadPaths);
+
+      expect(result.css).toBeDefined();
+      expect(result.dependencies.length).toBeGreaterThan(0);
+      expect(result.dependencies.some((d) => d.includes("_variables.scss"))).toBe(true);
+    });
+
+    // Acceptance: Scenario "node_modules 패키지 경로 @use를 해석한다"
+    it("resolves node_modules package @use paths", () => {
+      const source =
+        '@use "@simplysm/angular/scss/commons/variables";\n.test { display: block; }';
+      const containingFile = resolve(tmpDir, "src/fake-component.ts");
+      const loadPaths = [resolve(tmpDir, "node_modules")];
+
+      const result = compileScssString(source, containingFile, loadPaths);
+
+      expect(result.css).toBeDefined();
+      expect(result.dependencies.length).toBeGreaterThan(0);
+      expect(
+        result.dependencies.some((d) => d.includes("_variables.scss")),
+      ).toBe(true);
+    });
+
+    // Acceptance: Scenario "해석 실패 시 컴파일 에러가 발생한다"
+    it("throws when @use path cannot be resolved", () => {
+      const source = '@use "nonexistent/module";\n.test { display: block; }';
+      const containingFile = resolve(angularPkgDir, "src/fake-component.ts");
+      const loadPaths: string[] = [];
+
+      expect(() => compileScssString(source, containingFile, loadPaths)).toThrow();
+    });
+  });
+
+  describe("compileScssFile", () => {
+    // Acceptance: Scenario "styleUrls의 .scss 파일이 CSS로 컴파일된다"
+    it("compiles an external SCSS file to CSS", () => {
+      const filePath = resolve(angularPkgDir, "scss/styles.scss");
+      const loadPaths = [resolve(angularPkgDir, "scss")];
+
+      const result = compileScssFile(filePath, loadPaths);
+
+      expect(result.css).toContain("ng-icon");
+      expect(result.dependencies.length).toBeGreaterThan(0);
+    });
+
+    // Unit: dependencies include loaded partial files
+    it("includes loaded partial files in dependencies", () => {
+      const filePath = resolve(angularPkgDir, "scss/styles.scss");
+      const loadPaths = [resolve(angularPkgDir, "scss")];
+
+      const result = compileScssFile(filePath, loadPaths);
+
+      expect(
+        result.dependencies.some(
+          (d) => d.includes("_theme-variables.scss") || d.includes("_styles.scss"),
+        ),
+      ).toBe(true);
+    });
+  });
+});

package/tests/utils/sd-config.spec.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockExists = vi.fn();
+const mockJitiImport = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  fsx: {
+    exists: (...args: unknown[]) => mockExists(...args),
+  },
+}));
+
+vi.mock("jiti", () => ({
+  createJiti: () => ({
+    import: (...args: unknown[]) => mockJitiImport(...args),
+  }),
+}));
+
+const { loadSdConfig } = await import("../../src/utils/sd-config");
+
+describe("loadSdConfig", () => {
+  const baseParams = { cwd: "/project", dev: true, options: [] as string[] };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns SdConfig on valid config", async () => {
+    mockExists.mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({ packages: { core: { target: "node" } } }),
+    });
+
+    const config = await loadSdConfig(baseParams);
+    expect(config.packages).toBeDefined();
+    expect(config.packages["core"]).toEqual({ target: "node" });
+  });
+
+  it("throws when sd.config.ts does not exist", async () => {
+    mockExists.mockResolvedValue(false);
+
+    await expect(loadSdConfig(baseParams)).rejects.toThrow("sd.config.ts file not found");
+  });
+
+  it("throws when default export is not a function", async () => {
+    mockExists.mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({ default: "not-a-function" });
+
+    await expect(loadSdConfig(baseParams)).rejects.toThrow("must export a function as default");
+  });
+
+  it("throws when module has no default export", async () => {
+    mockExists.mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({ notDefault: true });
+
+    await expect(loadSdConfig(baseParams)).rejects.toThrow("must export a function as default");
+  });
+
+  it("throws when config has no packages property", async () => {
+    mockExists.mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({ noPkgs: true }),
+    });
+
+    await expect(loadSdConfig(baseParams)).rejects.toThrow("not in the correct format");
+  });
+
+  it("passes params to the config function", async () => {
+    const configFn = vi.fn(() => ({ packages: { a: { target: "node" } } }));
+    mockExists.mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({ default: configFn });
+
+    const params = { cwd: "/project", dev: true, options: ["key=val"] };
+    await loadSdConfig(params);
+
+    expect(configFn).toHaveBeenCalledWith(params);
+  });
+});