gencow 0.1.76 → 0.1.78

package/lib/__tests__/deploy-auditor.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Deploy Auditor — Unit Tests
+ *
+ * Tests the pure functions in deploy-auditor.mjs.
+ * Note: auditDeployDependencies() requires esbuild and actual files,
+ * so we only test the utility functions here.
+ */
+import { describe, it, expect } from "vitest";
+import {
+    isPlatformPackage,
+    isNodeBuiltin,
+    formatAuditError,
+    getPlatformPackageList,
+} from "../deploy-auditor.mjs";
+
+describe("isPlatformPackage", () => {
+    it("recognizes exact platform packages", () => {
+        expect(isPlatformPackage("@gencow/core")).toBe(true);
+        expect(isPlatformPackage("drizzle-orm")).toBe(true);
+        expect(isPlatformPackage("better-auth")).toBe(true);
+        expect(isPlatformPackage("postgres")).toBe(true);
+        expect(isPlatformPackage("hono")).toBe(true);
+        expect(isPlatformPackage("esbuild")).toBe(true);
+        expect(isPlatformPackage("ai")).toBe(true);
+        expect(isPlatformPackage("zod")).toBe(true);
+    });
+
+    it("recognizes subpath imports of platform packages", () => {
+        expect(isPlatformPackage("drizzle-orm/pg-core")).toBe(true);
+        expect(isPlatformPackage("drizzle-orm/node-postgres")).toBe(true);
+        expect(isPlatformPackage("hono/cors")).toBe(true);
+        expect(isPlatformPackage("hono/logger")).toBe(true);
+        expect(isPlatformPackage("hono/bun")).toBe(true);
+        expect(isPlatformPackage("better-auth/plugins")).toBe(true);
+        expect(isPlatformPackage("@gencow/core/reactive")).toBe(true);
+        expect(isPlatformPackage("@ai-sdk/openai")).toBe(true);
+        expect(isPlatformPackage("@ai-sdk/openai/something")).toBe(true);
+    });
+
+    it("rejects non-platform packages", () => {
+        expect(isPlatformPackage("langfuse")).toBe(false);
+        expect(isPlatformPackage("openai")).toBe(false);
+        expect(isPlatformPackage("axios")).toBe(false);
+        expect(isPlatformPackage("lodash")).toBe(false);
+        expect(isPlatformPackage("@prisma/client")).toBe(false);
+        expect(isPlatformPackage("cheerio")).toBe(false);
+    });
+});
+
+describe("isNodeBuiltin", () => {
+    it("recognizes Node builtins", () => {
+        expect(isNodeBuiltin("fs")).toBe(true);
+        expect(isNodeBuiltin("path")).toBe(true);
+        expect(isNodeBuiltin("crypto")).toBe(true);
+        expect(isNodeBuiltin("http")).toBe(true);
+        expect(isNodeBuiltin("events")).toBe(true);
+    });
+
+    it("recognizes node: prefixed builtins", () => {
+        expect(isNodeBuiltin("node:fs")).toBe(true);
+        expect(isNodeBuiltin("node:path")).toBe(true);
+        expect(isNodeBuiltin("node:crypto")).toBe(true);
+        expect(isNodeBuiltin("node:stream")).toBe(true);
+    });
+
+    it("recognizes subpath builtins", () => {
+        expect(isNodeBuiltin("fs/promises")).toBe(true);
+        expect(isNodeBuiltin("node:fs/promises")).toBe(true);
+        expect(isNodeBuiltin("stream/web")).toBe(true);
+        expect(isNodeBuiltin("util/types")).toBe(true);
+    });
+
+    it("rejects non-builtins", () => {
+        expect(isNodeBuiltin("langfuse")).toBe(false);
+        expect(isNodeBuiltin("drizzle-orm")).toBe(false);
+        expect(isNodeBuiltin("@gencow/core")).toBe(false);
+    });
+});
+
+describe("formatAuditError", () => {
+    it("returns empty string when passed", () => {
+        expect(formatAuditError({ passed: true, unsupported: [] })).toBe("");
+    });
+
+    it("formats error with unsupported packages", () => {
+        const result = {
+            passed: false,
+            unsupported: [
+                { packageName: "langfuse", importedFrom: "gencow/llmActions.ts" },
+                { packageName: "cheerio", importedFrom: "gencow/crawlPipeline.ts" },
+            ],
+        };
+        const output = formatAuditError(result);
+        expect(output).toContain("DEPLOY BLOCKED");
+        expect(output).toContain("langfuse");
+        expect(output).toContain("gencow/llmActions.ts");
+        expect(output).toContain("cheerio");
+        expect(output).toContain("gencow/crawlPipeline.ts");
+        expect(output).toContain("--force");
+    });
+
+    it("includes platform package list in error", () => {
+        const result = {
+            passed: false,
+            unsupported: [{ packageName: "moment", importedFrom: "gencow/utils.ts" }],
+        };
+        const output = formatAuditError(result);
+        expect(output).toContain("@gencow/core");
+        expect(output).toContain("drizzle-orm");
+        expect(output).toContain("better-auth");
+    });
+});
+
+describe("getPlatformPackageList", () => {
+    it("returns sorted list of platform packages", () => {
+        const list = getPlatformPackageList();
+        expect(list).toContain("@gencow/core");
+        expect(list).toContain("drizzle-orm");
+        expect(list).toContain("hono");
+        expect(Array.isArray(list)).toBe(true);
+        // Verify sorted
+        const sorted = [...list].sort();
+        expect(list).toEqual(sorted);
+    });
+});

package/lib/__tests__/env-parser.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "bun:test";
+import {
+    parseEnvFile,
+    isValidEnvKey,
+    serializeEnvFile,
+} from "../env-parser.mjs";
+
+describe("parseEnvFile", () => {
+    it("기본 KEY=VALUE 파싱", () => {
+        const result = parseEnvFile("FOO=bar\nBAZ=qux");
+        expect(result).toEqual({ FOO: "bar", BAZ: "qux" });
+    });
+
+    it("빈 문자열 → 빈 객체", () => {
+        expect(parseEnvFile("")).toEqual({});
+    });
+
+    it("null/undefined → 빈 객체", () => {
+        expect(parseEnvFile(null)).toEqual({});
+        expect(parseEnvFile(undefined)).toEqual({});
+    });
+
+    it("주석 무시 (#으로 시작)", () => {
+        const result = parseEnvFile("# comment\nFOO=bar\n# another");
+        expect(result).toEqual({ FOO: "bar" });
+    });
+
+    it("빈 줄 무시", () => {
+        const result = parseEnvFile("\n\nFOO=bar\n\n\nBAZ=1\n\n");
+        expect(result).toEqual({ FOO: "bar", BAZ: "1" });
+    });
+
+    it("따옴표 제거 (큰따옴표)", () => {
+        const result = parseEnvFile('KEY="value with spaces"');
+        expect(result).toEqual({ KEY: "value with spaces" });
+    });
+
+    it("따옴표 제거 (작은따옴표)", () => {
+        const result = parseEnvFile("KEY='value with spaces'");
+        expect(result).toEqual({ KEY: "value with spaces" });
+    });
+
+    it("값에 = 포함 (첫 번째 = 기준 분리)", () => {
+        const result = parseEnvFile("DATABASE_URL=postgres://user:pass@host/db?ssl=true");
+        expect(result).toEqual({
+            DATABASE_URL: "postgres://user:pass@host/db?ssl=true",
+        });
+    });
+
+    it("값이 빈 경우", () => {
+        const result = parseEnvFile("EMPTY=");
+        expect(result).toEqual({ EMPTY: "" });
+    });
+
+    it("공백만 있는 줄 무시", () => {
+        const result = parseEnvFile("   \n  \t  \nFOO=bar");
+        expect(result).toEqual({ FOO: "bar" });
+    });
+
+    it("= 없는 줄 무시", () => {
+        const result = parseEnvFile("INVALID_LINE\nFOO=bar");
+        expect(result).toEqual({ FOO: "bar" });
+    });
+
+    it("키 앞뒤 공백 trim", () => {
+        const result = parseEnvFile("  KEY  = value  ");
+        expect(result).toEqual({ KEY: "value" });
+    });
+
+    it("실제 .env 파일 시뮬레이션", () => {
+        const content = `# Gencow Environment
+DATABASE_URL=postgres://localhost:5432/mydb
+OPENAI_API_KEY=sk-1234567890
+
+# Optional
+DEBUG=false
+APP_NAME="My App"
+`;
+        const result = parseEnvFile(content);
+        expect(result).toEqual({
+            DATABASE_URL: "postgres://localhost:5432/mydb",
+            OPENAI_API_KEY: "sk-1234567890",
+            DEBUG: "false",
+            APP_NAME: "My App",
+        });
+    });
+});
+
+describe("isValidEnvKey", () => {
+    it("유효한 키", () => {
+        expect(isValidEnvKey("FOO")).toBe(true);
+        expect(isValidEnvKey("_PRIVATE")).toBe(true);
+        expect(isValidEnvKey("DATABASE_URL")).toBe(true);
+        expect(isValidEnvKey("key123")).toBe(true);
+    });
+
+    it("무효한 키", () => {
+        expect(isValidEnvKey("123FOO")).toBe(false);
+        expect(isValidEnvKey("FOO-BAR")).toBe(false);
+        expect(isValidEnvKey("FOO BAR")).toBe(false);
+        expect(isValidEnvKey("")).toBe(false);
+        expect(isValidEnvKey("a.b")).toBe(false);
+    });
+});
+
+describe("serializeEnvFile", () => {
+    it("기본 직렬화", () => {
+        const result = serializeEnvFile({ FOO: "bar", BAZ: "1" });
+        expect(result).toBe("FOO=bar\nBAZ=1\n");
+    });
+
+    it("공백 포함 값은 따옴표 감싸기", () => {
+        const result = serializeEnvFile({ KEY: "hello world" });
+        expect(result).toBe('KEY="hello world"\n');
+    });
+
+    it("# 포함 값은 따옴표 감싸기", () => {
+        const result = serializeEnvFile({ KEY: "value#comment" });
+        expect(result).toBe('KEY="value#comment"\n');
+    });
+
+    it("빈 객체 → 빈 줄", () => {
+        const result = serializeEnvFile({});
+        expect(result).toBe("\n");
+    });
+
+    it("roundtrip — parse → serialize → parse", () => {
+        const original = "FOO=bar\nDB=postgres://localhost/db\n";
+        const parsed = parseEnvFile(original);
+        const serialized = serializeEnvFile(parsed);
+        const reparsed = parseEnvFile(serialized);
+        expect(reparsed).toEqual(parsed);
+    });
+});

package/lib/__tests__/project-validator.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "bun:test";
+import {
+    validateProjectStructure,
+    shouldExcludeFromDeploy,
+} from "../project-validator.mjs";
+
+describe("validateProjectStructure", () => {
+    it("유효한 프로젝트 — 에러 없음", () => {
+        const result = validateProjectStructure({
+            files: ["gencow/index.ts", "gencow/schema.ts", "package.json"],
+        });
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+
+    it("index.ts 누락 → 에러", () => {
+        const result = validateProjectStructure({
+            files: ["gencow/schema.ts", "package.json"],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it("schema.ts 누락 → 에러", () => {
+        const result = validateProjectStructure({
+            files: ["gencow/index.ts", "package.json"],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it("package.json 누락 → 경고 (에러 아님)", () => {
+        const result = validateProjectStructure({
+            files: ["gencow/index.ts", "gencow/schema.ts"],
+        });
+        expect(result.valid).toBe(true);
+        expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    it("crons.ts 존재 시 → 경고", () => {
+        const result = validateProjectStructure({
+            files: [
+                "gencow/index.ts",
+                "gencow/schema.ts",
+                "gencow/crons.ts",
+                "package.json",
+            ],
+        });
+        expect(result.valid).toBe(true);
+        expect(result.warnings.some((w) => w.includes("crons"))).toBe(true);
+    });
+
+    it("커스텀 functionsDir 지원", () => {
+        const result = validateProjectStructure({
+            files: ["backend/index.ts", "backend/schema.ts", "package.json"],
+            functionsDir: "backend",
+        });
+        expect(result.valid).toBe(true);
+    });
+
+    it(".js 파일도 허용", () => {
+        const result = validateProjectStructure({
+            files: ["gencow/index.js", "gencow/schema.js", "package.json"],
+        });
+        expect(result.valid).toBe(true);
+    });
+
+    it("완전히 빈 프로젝트 → 에러 2개", () => {
+        const result = validateProjectStructure({ files: [] });
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBe(2);
+    });
+});
+
+describe("shouldExcludeFromDeploy", () => {
+    it("node_modules 제외", () => {
+        expect(shouldExcludeFromDeploy("node_modules/foo/index.js")).toBe(true);
+    });
+
+    it(".git 제외", () => {
+        expect(shouldExcludeFromDeploy(".git/HEAD")).toBe(true);
+    });
+
+    it(".gencow 제외", () => {
+        expect(shouldExcludeFromDeploy(".gencow/data")).toBe(true);
+    });
+
+    it(".env 제외", () => {
+        expect(shouldExcludeFromDeploy(".env")).toBe(true);
+    });
+
+    it(".env.local 제외", () => {
+        expect(shouldExcludeFromDeploy(".env.local")).toBe(true);
+    });
+
+    it("테스트 파일 제외", () => {
+        expect(shouldExcludeFromDeploy("src/foo.test.ts")).toBe(true);
+        expect(shouldExcludeFromDeploy("src/foo.spec.js")).toBe(true);
+        expect(shouldExcludeFromDeploy("__tests__/bar.ts")).toBe(true);
+    });
+
+    it("dist 제외", () => {
+        expect(shouldExcludeFromDeploy("dist/index.js")).toBe(true);
+    });
+
+    it("coverage 제외", () => {
+        expect(shouldExcludeFromDeploy("coverage/lcov-report/index.html")).toBe(true);
+    });
+
+    it("일반 소스 파일은 포함", () => {
+        expect(shouldExcludeFromDeploy("gencow/index.ts")).toBe(false);
+        expect(shouldExcludeFromDeploy("gencow/schema.ts")).toBe(false);
+        expect(shouldExcludeFromDeploy("package.json")).toBe(false);
+    });
+
+    it(".DS_Store 제외", () => {
+        expect(shouldExcludeFromDeploy(".DS_Store")).toBe(true);
+    });
+});