Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

5.6 KB
Raw Blame
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
import {
  resolveDatabaseConfig,
  resolveDatabaseConnectionString,
} from "../../../apps/api/src/database/resolve-database-url";

const keys = [
  "DATABASE_URL",
  "DATABASE_POOL_MAX",
  "POSTGRES_HOST",
  "POSTGRES_PORT",
  "POSTGRES_DB",
  "POSTGRES_USER",
  "POSTGRES_PASSWORD",
  "POSTGRES_PASSWORD_FILE",
] as const;

describe("resolve-database-url", () => {
  const original: Partial<Record<(typeof keys)[number], string | undefined>> =
    {};
  let directory: string;

  beforeEach(() => {
    directory = mkdtempSync(path.join(tmpdir(), "kaneo-db-secret-"));
    for (const key of keys) {
      original[key] = process.env[key];
      delete process.env[key];
    }
  });

  afterEach(() => {
    for (const key of keys) {
      const value = original[key];
      if (value === undefined) {
        delete process.env[key];
      } else {
        process.env[key] = value;
      }
    }
    rmSync(directory, { recursive: true, force: true });
  });

  it("returns DATABASE_URL unchanged when explicitly configured", () => {
    process.env.DATABASE_URL = "postgresql://app:[email protected]:5433/appdb";

    expect(resolveDatabaseConnectionString()).toBe(
      "postgresql://app:[email protected]:5433/appdb",
    );

    expect(resolveDatabaseConfig()).toMatchObject({
      connectionString: "postgresql://app:[email protected]:5433/appdb",
      source: "DATABASE_URL",
      host: "example.com",
      port: 5433,
      database: "appdb",
      username: "app",
    });
  });

  it("derives DATABASE_URL from POSTGRES_* when a derivation signal is present", () => {
    process.env.POSTGRES_PASSWORD = "password";
    process.env.POSTGRES_HOST = "db.internal";
    process.env.POSTGRES_PORT = "6543";
    process.env.POSTGRES_DB = "kaneo_dev";
    process.env.POSTGRES_USER = "kaneo";

    expect(resolveDatabaseConfig()).toMatchObject({
      connectionString:
        "postgresql://kaneo:[email protected]:6543/kaneo_dev",
      source: "POSTGRES_ENV",
      host: "db.internal",
      port: 6543,
      database: "kaneo_dev",
      username: "kaneo",
    });
  });

  it("uses bundled-image defaults when deriving from POSTGRES_PASSWORD alone", () => {
    process.env.POSTGRES_PASSWORD = "password";

    expect(resolveDatabaseConfig()).toMatchObject({
      connectionString: "postgresql://kaneo:password@postgres:5432/kaneo",
      source: "POSTGRES_ENV",
      host: "postgres",
      port: 5432,
      database: "kaneo",
      username: "kaneo",
    });
  });

  it("derives and URL-encodes POSTGRES_PASSWORD_FILE when no direct password exists", () => {
    const file = path.join(directory, "db-password");
    writeFileSync(file, "space &/#%!'\n");
    process.env.POSTGRES_PASSWORD_FILE = file;

    expect(resolveDatabaseConfig()).toMatchObject({
      connectionString:
        "postgresql://kaneo:space%20%26%2F%23%25!'@postgres:5432/kaneo",
      source: "POSTGRES_ENV",
    });
  });

  it("keeps direct database credentials ahead of file credentials", () => {
    process.env.POSTGRES_PASSWORD = "direct";
    process.env.POSTGRES_PASSWORD_FILE = path.join(directory, "missing");
    expect(resolveDatabaseConnectionString()).toBe(
      "postgresql://kaneo:direct@postgres:5432/kaneo",
    );

    process.env.DATABASE_URL = "postgresql://app:[email protected]/app";
    process.env.POSTGRES_PASSWORD = "";
    expect(resolveDatabaseConnectionString()).toBe(process.env.DATABASE_URL);
  });

  it("fails when POSTGRES_PASSWORD_FILE is missing or empty", () => {
    const file = path.join(directory, "db-password");
    process.env.POSTGRES_PASSWORD_FILE = file;
    expect(() => resolveDatabaseConfig()).toThrow(
      "POSTGRES_PASSWORD_FILE could not be read",
    );

    writeFileSync(file, "\n");
    expect(() => resolveDatabaseConfig()).toThrow(
      "POSTGRES_PASSWORD_FILE points to an empty file",
    );
  });

  it("preserves the localhost fallback when only POSTGRES_DB and POSTGRES_USER are set", () => {
    process.env.POSTGRES_DB = "kaneo";
    process.env.POSTGRES_USER = "kaneo";

    expect(resolveDatabaseConfig()).toMatchObject({
      connectionString: "postgresql://localhost:5432/kaneo",
      source: "LOCAL_FALLBACK",
      host: "localhost",
      port: 5432,
      database: "kaneo",
      username: "",
    });
  });

  it("throws when derivation is attempted without POSTGRES_PASSWORD", () => {
    process.env.POSTGRES_HOST = "db.internal";

    expect(() => resolveDatabaseConfig()).toThrow(
      "POSTGRES_PASSWORD must be set when deriving DATABASE_URL from POSTGRES_* variables",
    );
  });

  it("exposes safe metadata without a password field", () => {
    process.env.POSTGRES_PASSWORD = "super-secret";

    const config = resolveDatabaseConfig();

    expect(config.logConfig).not.toHaveProperty("password");
    expect(JSON.stringify(config.logConfig)).not.toContain("super-secret");
  });

  it("includes the pool size in the resolved config and its log metadata", () => {
    process.env.DATABASE_URL = "postgresql://app:[email protected]:5433/appdb";
    process.env.DATABASE_POOL_MAX = "2";

    const config = resolveDatabaseConfig();

    expect(config.poolMax).toBe(2);
    expect(config.logConfig.poolMax).toBe(2);
  });

  it("fails config resolution when DATABASE_POOL_MAX is invalid", () => {
    process.env.DATABASE_URL = "postgresql://app:[email protected]:5433/appdb";
    process.env.DATABASE_POOL_MAX = "1";

    expect(() => resolveDatabaseConfig()).toThrow(
      "DATABASE_POOL_MAX must be an integer of at least 2",
    );
  });
});