571 lines
26 KiB
TypeScript
571 lines
26 KiB
TypeScript
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_BYTES,
|
||
ADMIN_PASSWORD_MAX_LENGTH,
|
||
ADMIN_PASSWORD_MIN_LENGTH,
|
||
ADMIN_USERNAME_CHARSET,
|
||
ADMIN_USERNAME_MAX_LENGTH,
|
||
ADMIN_USERNAME_MIN_LENGTH,
|
||
ADMIN_USERNAME_PATTERN,
|
||
isValidAdminPassword,
|
||
} from "../src/config/profile";
|
||
import {
|
||
ADMIN_LOGIN_SMOKE_USER_AGENT,
|
||
buildAdminLoginRequest,
|
||
isRejectedLogin,
|
||
isSuccessfulLogin,
|
||
} from "../src/steps/smoke";
|
||
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", "credential", "admin.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/credential/admin.go`);
|
||
}
|
||
|
||
/**
|
||
* Содержимое файла без комментариев.
|
||
*
|
||
* Проверять положено КОД, а не упоминания: комментарий, объясняющий, почему
|
||
* убранной конструкции здесь больше нет, обязан называть её по имени, иначе он
|
||
* бесполезен, — и проверка «такой конструкции в файле нет» начинает падать
|
||
* ровно на той документации, которая описывает выполненную ею же работу.
|
||
*/
|
||
function codeOf(source: string): string {
|
||
return source
|
||
.split("\n")
|
||
.filter((line) => !/^\s*(\/\/|\/?\*)/.test(line))
|
||
.join("\n");
|
||
}
|
||
|
||
describe("контракт учётных данных совпадает с админкой", () => {
|
||
// Копия контракта в TypeScript неизбежна: оркестратор собирается отдельно от
|
||
// Go-бинарника и импортировать его константы не может. Проверяется поэтому
|
||
// не отсутствие копии, а её совпадение с оригиналом — сверкой по исходнику.
|
||
test("границы совпадают с credential.Admin*", () => {
|
||
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"),
|
||
);
|
||
// Предел bcrypt — ОТДЕЛЬНАЯ константа и отдельная сверка: пока его тут не
|
||
// было, оркестратор пропускал в hy2xs.env пароль, который админка не могла
|
||
// захешировать, и установка заканчивалась сервером без администратора.
|
||
expect(String(ADMIN_PASSWORD_MAX_BYTES)).toBe(
|
||
goConst("AdminPasswordMaxBytes"),
|
||
);
|
||
});
|
||
|
||
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);
|
||
}
|
||
});
|
||
|
||
// Границ ДВЕ, и они в разных единицах.
|
||
//
|
||
// Здесь стоял тест «длина считается в символах, а не в байтах», требовавший
|
||
// приёма 64 кириллических букв. Он закреплял как ожидаемое ровно то значение,
|
||
// на котором продукт ломался: 64 символа — это 128 байт, а
|
||
// bcrypt.GenerateFromPassword отвечает ErrPasswordTooLong строго при длине
|
||
// больше 72 байт. Установка проходила целиком, а первая учётная запись
|
||
// администратора не создавалась вовсе.
|
||
//
|
||
// Длина по-прежнему считается в СИМВОЛАХ — иначе оркестратор был бы строже
|
||
// панели, — но байтовая граница существует одновременно с ней.
|
||
test("границы пароля проверяются и в символах, и в байтах", () => {
|
||
// Проверка самой таблицы: если «я» перестанет быть двухбайтовой, случаи
|
||
// ниже проверяли бы не то, что написано.
|
||
expect(Buffer.byteLength("я".repeat(36), "utf8")).toBe(
|
||
ADMIN_PASSWORD_MAX_BYTES,
|
||
);
|
||
expect(Buffer.byteLength("😀".repeat(18), "utf8")).toBe(
|
||
ADMIN_PASSWORD_MAX_BYTES,
|
||
);
|
||
|
||
const accepted = [
|
||
"a".repeat(ADMIN_PASSWORD_MIN_LENGTH),
|
||
"a".repeat(ADMIN_PASSWORD_MAX_LENGTH),
|
||
"я".repeat(36),
|
||
"😀".repeat(18),
|
||
"abcde ",
|
||
" ".repeat(ADMIN_PASSWORD_MIN_LENGTH),
|
||
];
|
||
for (const password of accepted) {
|
||
expect(isValidAdminPassword(password)).toBe(true);
|
||
expect(
|
||
baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: `"${password}"` })
|
||
.adminInitialPassword,
|
||
).toBe(password);
|
||
}
|
||
|
||
const rejected = [
|
||
"a".repeat(ADMIN_PASSWORD_MIN_LENGTH - 1),
|
||
"a".repeat(ADMIN_PASSWORD_MAX_LENGTH + 1),
|
||
"я".repeat(37),
|
||
"😀".repeat(19),
|
||
"я".repeat(ADMIN_PASSWORD_MAX_LENGTH),
|
||
];
|
||
for (const password of rejected) {
|
||
expect(isValidAdminPassword(password)).toBe(false);
|
||
expect(() =>
|
||
baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: `"${password}"` }),
|
||
).toThrow(/invalid HY2XS_ADMIN_INITIAL_PASSWORD/);
|
||
}
|
||
});
|
||
|
||
// Отказ обязан НАЗЫВАТЬ обе границы: пароль из 40 эмодзи укладывается в 64
|
||
// символа и не укладывается в 72 байта, и сообщение «не длиннее 64 символов»
|
||
// отправило бы оператора сокращать пароль, отвергнутый не за это.
|
||
test("отказ называет и символы, и байты", () => {
|
||
const tooManyBytes = `"${"я".repeat(ADMIN_PASSWORD_MAX_LENGTH)}"`;
|
||
expect(() =>
|
||
baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: tooManyBytes }),
|
||
).toThrow(new RegExp(`${ADMIN_PASSWORD_MAX_BYTES} байт`));
|
||
expect(() =>
|
||
baselineConfig({ HY2XS_ADMIN_INITIAL_PASSWORD: tooManyBytes }),
|
||
).toThrow(
|
||
new RegExp(`${ADMIN_PASSWORD_MIN_LENGTH}.*${ADMIN_PASSWORD_MAX_LENGTH}`),
|
||
);
|
||
});
|
||
|
||
// Управляющий символ отвергается контрактом, а не теряется транспортом.
|
||
test("управляющий символ в пароле роняет установку", () => {
|
||
expect(isValidAdminPassword("abcde\n")).toBe(false);
|
||
expect(isValidAdminPassword("abcde\t")).toBe(false);
|
||
});
|
||
|
||
// Сгенерированный пароль обязан проходить контракт ЦЕЛИКОМ, включая байты:
|
||
// генератор — такой же источник значения, как и оператор.
|
||
test("сгенерированный пароль проходит контракт целиком", () => {
|
||
for (let i = 0; i < 50; i += 1) {
|
||
const config = parseRuntimeEnv(
|
||
envText({ HY2XS_ADMIN_INITIAL_PASSWORD: "__GENERATE__" }),
|
||
);
|
||
expect(isValidAdminPassword(config.adminInitialPassword)).toBe(true);
|
||
}
|
||
});
|
||
});
|
||
|
||
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("успех определяется конвертом ответа и выданным токеном", () => {
|
||
expect(
|
||
isSuccessfulLogin(
|
||
JSON.stringify({
|
||
code: 20000,
|
||
type: "ok",
|
||
data: { accessToken: "jwt", tokenType: "Bearer" },
|
||
}),
|
||
),
|
||
).toBe(true);
|
||
expect(
|
||
isSuccessfulLogin(
|
||
JSON.stringify({ code: 50000, data: { accessToken: "jwt" } }),
|
||
),
|
||
).toBe(false);
|
||
expect(
|
||
isSuccessfulLogin(
|
||
JSON.stringify({ code: 20000, data: { accessToken: "" } }),
|
||
),
|
||
).toBe(false);
|
||
expect(isSuccessfulLogin("not json")).toBe(false);
|
||
});
|
||
|
||
test("учётные данные не попадают ни в команду ошибки, ни в сообщение", () => {
|
||
const source = smoke();
|
||
const start = source.indexOf("async function assertAdminLoginWorks");
|
||
expect(start).toBeGreaterThan(-1);
|
||
const body = source.slice(start, source.indexOf("\ntype JsonObject"));
|
||
|
||
// runReadOnly (без Secret) кладёт команду в текст ошибки, а команда несёт
|
||
// пароль администратора.
|
||
expect(body).not.toMatch(/(?<!Secret)runReadOnly`/);
|
||
expect(body.match(/runReadOnlySecret`/g)).toHaveLength(1);
|
||
|
||
// Подстановка в 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",
|
||
"request.body",
|
||
"response",
|
||
"body}",
|
||
]) {
|
||
expect(message).not.toContain(`\${${secret}`);
|
||
}
|
||
}
|
||
|
||
// Тело успешного ответа несёт токен доступа, поэтому наружу отдаётся только
|
||
// разбор ответа, а не он сам.
|
||
expect(body).toContain("describeLoginFailure(body, error)");
|
||
expect(body).toContain("describeIssuedToken(response)");
|
||
});
|
||
|
||
test("обе пробы используют один wire-helper", () => {
|
||
const source = codeOf(smoke());
|
||
expect(source.match(/requestAdminLogin\(/g)).toHaveLength(3); // два вызова и определение
|
||
const helperStart = source.indexOf("async function requestAdminLogin");
|
||
const helper = source.slice(
|
||
helperStart,
|
||
source.indexOf("type JsonObject", helperStart),
|
||
);
|
||
expect(helperStart).toBeGreaterThan(-1);
|
||
expect(helper.match(/runReadOnlySecret`curl/g)).toHaveLength(1);
|
||
});
|
||
|
||
test("wire-тело содержит pass, а не несовместимый alias password", () => {
|
||
const request = buildAdminLoginRequest('admin"name', "pass\\word ");
|
||
expect(JSON.parse(request.body)).toEqual({
|
||
username: 'admin"name',
|
||
pass: "pass\\word ",
|
||
});
|
||
expect(request.body).not.toContain('"password"');
|
||
expect(request.contentType).toBe("application/json");
|
||
});
|
||
|
||
test("UA smoke проходит действующее scanner-правило", () => {
|
||
const filter = fs.readFileSync(
|
||
path.join(REPO_ROOT, "apps", "middleware", "filter.go"),
|
||
"utf8",
|
||
);
|
||
const declared = filter.match(/regexp\.MatchString\(`\(\?i\)([^`]+)`/);
|
||
expect(declared).not.toBeNull();
|
||
const scannerPattern = new RegExp(declared![1], "i");
|
||
|
||
expect(scannerPattern.test("curl/8.10.1")).toBe(true);
|
||
expect(scannerPattern.test(ADMIN_LOGIN_SMOKE_USER_AGENT)).toBe(false);
|
||
expect(buildAdminLoginRequest("hy2xsadmin", "secret1").userAgent).toBe(
|
||
ADMIN_LOGIN_SMOKE_USER_AGENT,
|
||
);
|
||
});
|
||
|
||
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);
|
||
});
|
||
|
||
// Отрицательная проба обязана доказывать ОТКАЗ.
|
||
//
|
||
// Она проверяла `code.trim() === "200"`, то есть ровно одно: что запрос не
|
||
// закончился пятисоткой. Админка отвечает HTTP 200 и на успешный вход тоже,
|
||
// поэтому «неверные учётные данные отвергнуты» этой проверкой не следовало.
|
||
test("отрицательная проба сверяет конверт отказа, а не код HTTP", () => {
|
||
const rejected = {
|
||
code: 50000,
|
||
type: "no",
|
||
errors: [{ code: "invalid_credentials", message: "wrong password" }],
|
||
data: null,
|
||
};
|
||
expect(isRejectedLogin(JSON.stringify(rejected))).toBe(true);
|
||
expect(isRejectedLogin(JSON.stringify({ ...rejected, code: 50001 }))).toBe(
|
||
false,
|
||
);
|
||
expect(
|
||
isRejectedLogin(
|
||
JSON.stringify({ ...rejected, errors: [{ code: "required" }] }),
|
||
),
|
||
).toBe(false);
|
||
expect(
|
||
isRejectedLogin(
|
||
JSON.stringify({
|
||
...rejected,
|
||
data: { accessToken: "unexpected-token" },
|
||
}),
|
||
),
|
||
).toBe(false);
|
||
expect(isRejectedLogin(JSON.stringify({ ...rejected, data: { accessToken: "" } }))).toBe(
|
||
false,
|
||
);
|
||
expect(
|
||
isRejectedLogin(
|
||
JSON.stringify({
|
||
code: 50000,
|
||
message: 'fake {"code":"invalid_credentials"}',
|
||
data: null,
|
||
}),
|
||
),
|
||
).toBe(false);
|
||
expect(isRejectedLogin("not json")).toBe(false);
|
||
});
|
||
|
||
// Доменный код обязан совпадать с тем, который объявляет админка.
|
||
test("код причины отказа совпадает с constant.ErrCodeInvalidCredentials", () => {
|
||
const goErrors = fs.readFileSync(
|
||
path.join(REPO_ROOT, "apps", "model", "constant", "error.go"),
|
||
"utf8",
|
||
);
|
||
const declared = goErrors.match(
|
||
/ErrCodeInvalidCredentials\s+string\s*=\s*"([^"]+)"/,
|
||
);
|
||
expect(declared).not.toBeNull();
|
||
expect(smoke()).toContain(`INVALID_CREDENTIALS_CODE = "${declared![1]}"`);
|
||
});
|
||
|
||
// Пароль отрицательной пробы не имеет права быть литералом: записанное в
|
||
// исходнике значение теоретически может оказаться настоящим паролем, и тогда
|
||
// проверка «неверные данные отвергаются» отчиталась бы об успешном ВХОДЕ.
|
||
test("пароль отрицательной пробы генерируется, а не записан в исходнике", () => {
|
||
const source = smoke();
|
||
// Считается КОД, а не упоминания: комментарий, объясняющий, почему прежнего
|
||
// литерала здесь больше нет, обязан называть его по имени — иначе он
|
||
// бесполезен. Тот же урок уже записан в code_without_comments в
|
||
// acceptance.sh и в codeOf во frontend-contract.test.ts.
|
||
expect(codeOf(source)).not.toContain("definitely-not-the-admin-password");
|
||
expect(source).toContain('randomBytes(24).toString("base64url")');
|
||
expect(source).toContain(
|
||
"negative login probe accidentally used the real admin password",
|
||
);
|
||
});
|
||
|
||
// Bootstrap-секрет читается ПАРСЕРОМ того же формата, которым он написан.
|
||
//
|
||
// Прежнее `grep … | cut -d= -f2-` с `.trim()` было третьим по счёту слоем,
|
||
// срезающим краевые пробелы у пароля, набор символов которого объявлен
|
||
// неограниченным: положительная проба брала не тот пароль и объявляла бы
|
||
// рабочую установку сломанной.
|
||
test("bootstrap-секрет читается парсером формата, а не шелл-конвейером", () => {
|
||
const source = smoke();
|
||
|
||
expect(source).toContain("readBootstrapAdminSecret");
|
||
expect(source).toContain(
|
||
"parseEnvFile(await readText(context.config.bootstrapAdminSecretPath))",
|
||
);
|
||
|
||
// Извлечения значения шеллом не остаётся ни одного. Проверки НАЛИЧИЯ
|
||
// ключей (`grep -q '^ADMIN_USER='`) при этом законны и остаются: они
|
||
// отвечают на другой вопрос — цел ли файл, — и значения не читают.
|
||
expect(codeOf(source)).not.toContain("cut -d= -f2-");
|
||
});
|
||
});
|