HY2XS_flamy/orchestrator/test/admin-credentials.test.ts

import { describe, expect, test } from "bun:test";
import fs from "node:fs";
import path from "node:path";

import { parseRuntimeEnv } from "../src/config/env";
import {
  ADMIN_LOGIN_PATH,
  ADMIN_PASSWORD_MAX_LENGTH,
  ADMIN_PASSWORD_MIN_LENGTH,
  ADMIN_USERNAME_CHARSET,
  ADMIN_USERNAME_MAX_LENGTH,
  ADMIN_USERNAME_MIN_LENGTH,
  ADMIN_USERNAME_PATTERN
} from "../src/config/profile";
import { baselineConfig, envText } from "./fixtures";

/**
 * Контракт учётных данных администратора на стороне оркестратора.
 *
 * Оркестратор ПОРОЖДАЕТ имя и первый пароль администратора, а принимает их
 * панель — по правилам, которых он раньше не знал вовсе. RC2 показал, чем это
 * заканчивается: установка завершается `INSTALL EXIT CODE: 0`, а войти в панель
 * нельзя. Отказ обязан приходить установщику, которому он чинится одной строкой
 * в hy2xs.env, а не оператору на форме входа, где чинить его уже нечем.
 */

const REPO_ROOT = path.resolve(import.meta.dir, "..", "..");

function goContract(): string {
  return fs.readFileSync(
    path.join(REPO_ROOT, "apps", "service", "admin_credentials.go"),
    "utf8"
  );
}

function goConst(name: string): string {
  const source = goContract();
  const numeric = source.match(new RegExp(`\\b${name}\\s*=\\s*(\\d+)`));
  if (numeric) {
    return numeric[1];
  }
  const backticked = source.match(new RegExp(`\\b${name}\\s*=\\s*\`([^\`]*)\``));
  if (backticked) {
    return backticked[1];
  }
  throw new Error(`константа ${name} не найдена в apps/service/admin_credentials.go`);
}

describe("контракт учётных данных совпадает с админкой", () => {
  // Копия контракта в TypeScript неизбежна: оркестратор собирается отдельно от
  // Go-бинарника и импортировать его константы не может. Проверяется поэтому
  // не отсутствие копии, а её совпадение с оригиналом — сверкой по исходнику.
  test("границы длины совпадают с service.Admin*Length", () => {
    expect(String(ADMIN_USERNAME_MIN_LENGTH)).toBe(goConst("AdminUsernameMinLength"));
    expect(String(ADMIN_USERNAME_MAX_LENGTH)).toBe(goConst("AdminUsernameMaxLength"));
    expect(String(ADMIN_PASSWORD_MIN_LENGTH)).toBe(goConst("AdminPasswordMinLength"));
    expect(String(ADMIN_PASSWORD_MAX_LENGTH)).toBe(goConst("AdminPasswordMaxLength"));
  });

  test("набор символов логина совпадает с классом из Go", () => {
    // Класс сравнивается как ЗНАЧЕНИЕ строки, а не как запись: в Go он живёт в
    // raw-строке, в TypeScript — в обычной, где обратный слеш удваивается.
    const declared = goConst("adminUsernameCharacterClass");
    const mirrored = ADMIN_USERNAME_PATTERN.source.replace(
      new RegExp(`^\\^\\[|\\]\\{${ADMIN_USERNAME_MIN_LENGTH},${ADMIN_USERNAME_MAX_LENGTH}\\}\\$$`, "g"),
      ""
    );
    expect(mirrored).toBe(declared);
  });

  test("человекочитаемый набор совпадает с показываемым админкой", () => {
    expect(ADMIN_USERNAME_CHARSET).toBe(goConst("AdminUsernameCharset"));
  });

  // Дефис в классе символов ЭКРАНИРОВАН. Без экранирования `+-=` образует
  // диапазон и молча впускает `, - . / 0-9 : ; < =` — ровно тот дефект, из-за
  // которого фактическое множество разошлось с задуманным на всех четырёх
  // сторонах продукта.
  test("дефис в классе экранирован, а не образует диапазон", () => {
    expect(ADMIN_USERNAME_PATTERN.source).toContain("\\-");
    expect(ADMIN_USERNAME_PATTERN.source).not.toContain("+-=");
  });

  test("путь формы входа собран из базового пространства имён API", () => {
    expect(ADMIN_LOGIN_PATH).toBe("/api/auth/login");

    const router = fs.readFileSync(path.join(REPO_ROOT, "apps", "router", "auth.go"), "utf8");
    expect(router).toContain('auth.POST("/login"');
    expect(router).toContain('authApi.Group("/auth")');
  });
});

describe("HY2XS_ADMIN_USER проверяется при разборе окружения", () => {
  test("значение по умолчанию проходит контракт панели", () => {
    const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_USER: null }));
    expect(config.adminUser).toBe("hy2xsadmin");
    expect(ADMIN_USERNAME_PATTERN.test(config.adminUser)).toBe(true);
  });

  // Регрессия: умолчанием здесь стояло `admin` — пять символов при минимуме в
  // шесть. Установка проходила целиком, а панель не впускала никого.
  test("значение по умолчанию не короче минимума", () => {
    const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_USER: null }));
    expect(config.adminUser.length).toBeGreaterThanOrEqual(ADMIN_USERNAME_MIN_LENGTH);
  });

  // Умолчание обязано совпадать с запасным значением админки: иначе установка
  // без явного HY2XS_ADMIN_USER создаёт одну учётную запись, а админка при
  // повреждённом окружении ищет другую.
  test("умолчание совпадает с запасным значением админки и с packaged env", () => {
    const dao = fs.readFileSync(path.join(REPO_ROOT, "apps", "dao", "sqlite.go"), "utf8");
    expect(dao).toContain('adminUser = "hy2xsadmin"');

    const packaged = fs.readFileSync(
      path.join(REPO_ROOT, "package", "config", "hy2xs.env"),
      "utf8"
    );
    expect(packaged).toContain("HY2XS_ADMIN_USER=hy2xsadmin");
  });

  test("слишком короткий логин роняет установку", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(
      /invalid HY2XS_ADMIN_USER/
    );
  });

  test("слишком длинный логин роняет установку", () => {
    expect(() =>
      baselineConfig({ HY2XS_ADMIN_USER: "a".repeat(ADMIN_USERNAME_MAX_LENGTH + 1) })
    ).toThrow(/invalid HY2XS_ADMIN_USER/);
  });

  test("логин с пробелом, кириллицей или переводом строки роняет установку", () => {
    for (const rejected of ["hy2xs admin", "админ12", "hy2xs\tadmin"]) {
      expect(() => baselineConfig({ HY2XS_ADMIN_USER: rejected })).toThrow(
        /invalid HY2XS_ADMIN_USER/
      );
    }
  });

  test("отказ называет и границы, и набор символов", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(
      new RegExp(`${ADMIN_USERNAME_MIN_LENGTH}.*${ADMIN_USERNAME_MAX_LENGTH}`)
    );
    expect(() => baselineConfig({ HY2XS_ADMIN_USER: "admin" })).toThrow(/a-z A-Z 0-9/);
  });

  // Значение уезжает в hy2xs.env и оттуда в базу. Пробел по краям превращался
  // бы в часть имени учётной записи, и вход отказывал бы «неверным логином» —
  // отказом, который невозможно связать с причиной.
  test("окружающие пробелы снимаются, а не уезжают в имя учётной записи", () => {
    expect(baselineConfig({ HY2XS_ADMIN_USER: "  hy2xsadmin  " }).adminUser).toBe("hy2xsadmin");
  });

  test("точка в логине принимается: набор не сужается задним числом", () => {
    expect(baselineConfig({ HY2XS_ADMIN_USER: "admin.ops" }).adminUser).toBe("admin.ops");
  });
});

describe("HY2XS_ADMIN_INITIAL_PASSWORD проверяется при разборе окружения", () => {
  test("сгенерированный пароль проходит контракт панели", () => {
    for (const raw of ["", "__GENERATE__"]) {
      const config = parseRuntimeEnv(envText({ HY2XS_ADMIN_INITIAL_PASSWORD: raw }));
      const length = [...config.adminInitialPassword].length;
      expect(length).toBeGreaterThanOrEqual(ADMIN_PASSWORD_MIN_LENGTH);
      expect(length).toBeLessThanOrEqual(ADMIN_PASSWORD_MAX_LENGTH);
    }
  });

  test("слишком короткий пароль роняет установку", () => {
    expect(() => baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: "12345" })).toThrow(
      /invalid HY2XS_ADMIN_INITIAL_PASSWORD/
    );
  });

  test("слишком длинный пароль роняет установку", () => {
    expect(() =>
      baselineConfig({
        HY2XS_ADMIN_INITIAL_PASSWORD: "a".repeat(ADMIN_PASSWORD_MAX_LENGTH + 1)
      })
    ).toThrow(/invalid HY2XS_ADMIN_INITIAL_PASSWORD/);
  });

  // Набор символов пароля сервером не ограничивается, и оркестратор не имеет
  // права быть строже: отвергнутый здесь пароль сервер принял бы.
  test("пароль из произвольных символов принимается", () => {
    for (const password of ["p@ssw0rd?!", "пароль-администратора", "a b c d e f"]) {
      expect(baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: password }).adminInitialPassword).toBe(
        password
      );
    }
  });

  // Длина считается в РУНАХ: 32 кириллические буквы — это 64 байта, и проверка
  // по байтам отвергла бы пароль, который панель принимает.
  test("длина считается в символах, а не в байтах", () => {
    const cyrillic = "я".repeat(ADMIN_PASSWORD_MAX_LENGTH);
    expect(baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: cyrillic }).adminInitialPassword).toBe(
      cyrillic
    );
  });
});

describe("smoke выполняет настоящий вход в панель", () => {
  const smoke = () =>
    fs.readFileSync(path.join(REPO_ROOT, "orchestrator", "src", "steps", "smoke.ts"), "utf8");

  // Главный барьер этого релиза. Пока установка отвечала на вопрос «работает ли
  // панель» только фактом LISTEN и ответом /healthz, RC2 объявлял успешной
  // установку с полностью недоступной панелью.
  test("smoke обращается к форме входа, а не только к healthz", () => {
    const source = smoke();
    expect(source).toContain("ADMIN_LOGIN_PATH");
    expect(source).toContain("assertAdminLoginWorks");
    expect(source).toContain("isSuccessfulLogin");
  });

  test("успех определяется конвертом ответа и выданным токеном", () => {
    // Админка отвечает HTTP 200 и на отказ: проверка по коду HTTP приняла бы за
    // успешный вход любой отказ.
    const source = smoke();
    expect(source).toMatch(/"code"\\s\*:\\s\*20000/);
    expect(source).toMatch(/accessToken/);
  });

  test("учётные данные не попадают ни в команду ошибки, ни в сообщение", () => {
    const source = smoke();
    const start = source.indexOf("async function assertAdminLoginWorks");
    expect(start).toBeGreaterThan(-1);
    const body = source.slice(start, source.indexOf("\nfunction isSuccessfulLogin"));

    // runReadOnly (без Secret) кладёт команду в текст ошибки, а команда несёт
    // пароль администратора.
    expect(body).not.toMatch(/(?<!Secret)runReadOnly`/);
    expect(body).toMatch(/runReadOnlySecret`/);

    // Подстановка в tagged template — это НЕ утечка: значения там проходят
    // через shellQuote и в текст ошибки не попадают. Утечкой была бы подстановка
    // секрета в сообщение — в info() или в new Error(), — потому что оно уезжает
    // в журнал установки и в diagnostics-бандл.
    const messages = [
      ...body.matchAll(/\binfo\(([\s\S]*?)\);/g),
      ...body.matchAll(/new Error\(([\s\S]*?)\);/g)
    ].map((match) => match[1]);
    expect(messages.length).toBeGreaterThan(0);

    for (const message of messages) {
      for (const secret of ["adminPassword", "payload", "response", "body}"]) {
        expect(message).not.toContain(`\${${secret}`);
      }
    }

    // Тело успешного ответа несёт токен доступа, поэтому наружу отдаётся только
    // разбор ответа, а не он сам.
    expect(body).toContain("describeLoginFailure(body, error)");
    expect(body).toContain("describeIssuedToken(response)");
  });

  test("тело запроса собирается JSON.stringify, а не интерполяцией", () => {
    // Пароль задаёт оператор: кавычка или обратный слеш в нём сломали бы сам
    // запрос, и проверка объявила бы рабочую установку сломанной.
    const body = smoke();
    expect(body).toContain("JSON.stringify({ username: adminUser, pass: adminPassword })");
  });

  test("отрицательная проба не зависит от режима операции", () => {
    // Пароль в bootstrap-admin.secret устаревает в момент, когда оператор сменил
    // его в панели, поэтому положительная проба install-only. Отрицательная от
    // пароля не зависит и обязана работать всегда: именно она воспроизводит
    // дефект RC2.
    const source = smoke();
    const start = source.indexOf("async function assertAdminLoginWorks");
    const body = source.slice(start, source.indexOf("\nfunction isSuccessfulLogin"));

    const rejected = body.indexOf("admin login rejects wrong credentials");
    const modeGate = body.indexOf('context.mode !== "install"');
    expect(rejected).toBeGreaterThan(-1);
    expect(modeGate).toBeGreaterThan(rejected);
  });
});