Jesse_Chen
fd415e1d11
A zero-uncertainty exact declaration is accepted server-side as the active
minute, but the account write only answered {ok:true}. Every save path then
kept the draft it submitted, so the first consultation after initialization
asked for unverified_birth_time against an accepted profile and was rejected
with mode_changed before billing.
The account route now returns the status and active minute it derived, and
every profile save adopts that result instead of its own local guess.
Co-authored-by: Cursor <cursoragent@cursor.com>
503 lines
19 KiB
TypeScript
503 lines
19 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { existsSync, readFileSync } from "node:fs";
|
|
import test from "node:test";
|
|
import {
|
|
accountProfilePatchSchema,
|
|
resolveAccountBirthTimeApplicationPatch,
|
|
resolveAppliedAccountBirthTime,
|
|
} from "../src/lib/account-profile-patch.ts";
|
|
|
|
const source = readFileSync(new URL("../src/app/api/account/route.ts", import.meta.url), "utf8");
|
|
const patchSource = readFileSync(new URL("../src/lib/account-profile-patch.ts", import.meta.url), "utf8");
|
|
const reportedStatusMigration = readFileSync(
|
|
new URL("../supabase/migrations/20260726010000_backfill_reported_birth_time_status.sql", import.meta.url),
|
|
"utf8",
|
|
);
|
|
const acceptedExactFamilyMigration = readFileSync(
|
|
new URL("../supabase/migrations/20260816010000_accept_exact_family_birth_times.sql", import.meta.url),
|
|
"utf8",
|
|
);
|
|
const productionMigrationWorkflow = readFileSync(
|
|
new URL("../../.github/workflows/apply-production-rectification-migrations.yml", import.meta.url),
|
|
"utf8",
|
|
);
|
|
|
|
test("account API reads and returns the server-configured rectification price", () => {
|
|
assert.match(source, /parseRectificationPriceCredits\(\s*process\.env\.RECTIFICATION_PRICE_CREDITS,?\s*\)/);
|
|
assert.match(source, /rectificationPriceCredits/);
|
|
assert.doesNotMatch(source, /RECTIFICATION_PRICE_CREDITS[^\n]*\?\?\s*["']1["']/);
|
|
});
|
|
|
|
test("account API separates engine confirmation from an accepted usable chart time", () => {
|
|
assert.match(source, /hasConfirmedBirthTime:\s*profile\.birth_time_status === "confirmed"/);
|
|
assert.match(source, /hasUsableBirthTime:\s*\(profile\.birth_time_status === "accepted" \|\| profile\.birth_time_status === "confirmed"\)/);
|
|
});
|
|
|
|
test("account API routes staging admins to the configured exact admin host", () => {
|
|
assert.match(source, /readSelfHostedIdentityConfig\(process\.env\)\.adminOrigin/);
|
|
assert.match(source, /const adminUrl = isAdmin \? adminEntryUrl\(\) : null/);
|
|
assert.match(source, /adminUrl,/);
|
|
assert.doesNotMatch(source, /NEXT_PUBLIC_ADMIN|AUTH_ADMIN_ORIGIN/);
|
|
});
|
|
|
|
test("account GET falls back when global birthplace columns are not migrated yet", () => {
|
|
const getSource = source.slice(source.indexOf("export async function GET"), source.indexOf("export async function PATCH"));
|
|
|
|
assert.match(getSource, /profileError && isMissingProfileColumn\(profileError\)/);
|
|
assert.match(getSource, /select\("credits,active_birth_time[^"]*timezone_offset(?:,[^"]*)?"\)/);
|
|
assert.match(getSource, /birth_place_label: undefined/);
|
|
assert.match(getSource, /timezone_id: undefined/);
|
|
});
|
|
|
|
test("account API no longer reads or returns retired rectification cases", () => {
|
|
assert.doesNotMatch(source, /birth_time_rectification_v4_cases|birth_time_rectification_cases/);
|
|
assert.doesNotMatch(source, /rectificationCase/);
|
|
});
|
|
|
|
test("profile patch schema validates calendar, clock, source requirements, and location bounds", () => {
|
|
const valid = {
|
|
name: "岳辰",
|
|
birth_date: "2000-02-29",
|
|
reported_birth_time: "05:30",
|
|
birth_time_source: "family_exact",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
country_code: "CN",
|
|
province_code: "130000",
|
|
city_code: "130400",
|
|
district_code: "130406",
|
|
latitude: 36.420487,
|
|
longitude: 114.209936,
|
|
timezone_offset: 8,
|
|
};
|
|
|
|
assert.equal(accountProfilePatchSchema.safeParse(valid).success, true);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, uncertainty_before_minutes: 10, uncertainty_after_minutes: 10 }).success, true);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, birth_date: "2001-02-29" }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, reported_birth_time: "24:00" }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, uncertainty_before_minutes: 7, uncertainty_after_minutes: 7 }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, latitude: 91 }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ reported_birth_time: "05:30" }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ ...valid, longitude: null }).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({
|
|
...valid,
|
|
timezone_offset: null,
|
|
birth_place_label: "New York, New York, United States",
|
|
birth_place_type: "place",
|
|
birth_place_provider: "mapbox",
|
|
birth_place_provider_id: "place.123",
|
|
timezone_id: "America/New_York",
|
|
timezone_source: "iana_historical",
|
|
}).success, true);
|
|
assert.equal(accountProfilePatchSchema.safeParse({ name: "只改称呼" }).success, true);
|
|
assert.equal(accountProfilePatchSchema.safeParse({
|
|
...valid,
|
|
reported_birth_time: null,
|
|
birth_time_source: "period_only",
|
|
birth_time_period: null,
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
}).success, false);
|
|
assert.equal(accountProfilePatchSchema.safeParse({
|
|
...valid,
|
|
reported_birth_time: null,
|
|
birth_time_source: "unknown",
|
|
birth_time_period: "morning",
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
}).success, false);
|
|
});
|
|
|
|
test("ordinary declaration edits clear stale candidate application but never overwrite confirmed active time", () => {
|
|
const candidate = {
|
|
birth_date: "1997-08-08",
|
|
reported_birth_time: "05:30",
|
|
birth_time_source: "approximate",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 30,
|
|
uncertainty_after_minutes: 30,
|
|
active_birth_time: "05:18",
|
|
birth_time: "05:18",
|
|
birth_time_status: "candidate",
|
|
rectification_case_id: "11111111-1111-4111-8111-111111111111",
|
|
latitude: 36.420487,
|
|
longitude: 114.209936,
|
|
timezone_offset: 8,
|
|
} as const;
|
|
const edited = {
|
|
birth_date: candidate.birth_date,
|
|
reported_birth_time: "06:10",
|
|
birth_time_source: candidate.birth_time_source,
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 30,
|
|
uncertainty_after_minutes: 30,
|
|
} as const;
|
|
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(candidate, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(candidate, {
|
|
district_code: "130407",
|
|
}), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
for (const coordinatePatch of [
|
|
{ latitude: 36.420488 },
|
|
{ longitude: 114.209937 },
|
|
{ timezone_offset: 9 },
|
|
]) {
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(candidate, coordinatePatch), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
}
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
birth_time_status: "accepted",
|
|
}, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
birth_time_status: "confirmed",
|
|
}, edited), {});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
}, { timezone_offset: 7 }), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
active_birth_time: null,
|
|
birth_time: null,
|
|
birth_time_status: null,
|
|
rectification_case_id: null,
|
|
}, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
active_birth_time: null,
|
|
birth_time: null,
|
|
birth_time_status: null,
|
|
rectification_case_id: null,
|
|
reported_birth_time: edited.reported_birth_time,
|
|
}, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(null, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
birth_time_status: "accepted",
|
|
}, edited), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
birth_time_status: "confirmed",
|
|
}, edited), {});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...candidate,
|
|
active_birth_time: null,
|
|
birth_time_status: null,
|
|
reported_birth_time: edited.reported_birth_time,
|
|
}, edited), {});
|
|
});
|
|
|
|
test("zero-uncertainty family exact time becomes an accepted usable chart time", () => {
|
|
const exactDeclaration = {
|
|
birth_date: "1997-08-08",
|
|
reported_birth_time: "05:00",
|
|
birth_time_source: "family_exact",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
} as const;
|
|
const reportedExactProfile = {
|
|
...exactDeclaration,
|
|
reported_birth_time: "05:00:00",
|
|
active_birth_time: null,
|
|
birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
} as const;
|
|
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(null, exactDeclaration), {
|
|
active_birth_time: "05:00",
|
|
birth_time_status: "accepted",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(reportedExactProfile, exactDeclaration), {
|
|
active_birth_time: "05:00",
|
|
birth_time_status: "accepted",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...reportedExactProfile,
|
|
active_birth_time: "05:00:00",
|
|
birth_time_status: "accepted",
|
|
}, {
|
|
...exactDeclaration,
|
|
reported_birth_time: "05:40",
|
|
}), {
|
|
active_birth_time: "05:40",
|
|
birth_time_status: "accepted",
|
|
rectification_case_id: null,
|
|
});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...reportedExactProfile,
|
|
active_birth_time: "05:00:00",
|
|
birth_time_status: "confirmed",
|
|
}, {
|
|
...exactDeclaration,
|
|
reported_birth_time: "05:40",
|
|
}), {});
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch({
|
|
...reportedExactProfile,
|
|
active_birth_time: "05:00:00",
|
|
birth_time: "05:00:00",
|
|
birth_time_status: null,
|
|
}, {
|
|
...exactDeclaration,
|
|
reported_birth_time: "05:40",
|
|
}), {});
|
|
});
|
|
|
|
test("account PATCH answers with the birth-time truth it derived server-side", () => {
|
|
const exactDeclaration = {
|
|
birth_date: "1997-08-08",
|
|
reported_birth_time: "05:00",
|
|
birth_time_source: "family_exact",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
} as const;
|
|
const reportedExactProfile = {
|
|
...exactDeclaration,
|
|
reported_birth_time: "05:00:00",
|
|
active_birth_time: null,
|
|
birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
} as const;
|
|
|
|
// A client that keeps the declaration it submitted would consult as
|
|
// unverified_birth_time and be rejected by the consultation truth check.
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(
|
|
null,
|
|
resolveAccountBirthTimeApplicationPatch(null, exactDeclaration),
|
|
),
|
|
{ status: "accepted", activeTime: "05:00" },
|
|
);
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(
|
|
reportedExactProfile,
|
|
resolveAccountBirthTimeApplicationPatch(reportedExactProfile, exactDeclaration),
|
|
),
|
|
{ status: "accepted", activeTime: "05:00" },
|
|
);
|
|
const periodDeclaration = {
|
|
...exactDeclaration,
|
|
reported_birth_time: null,
|
|
birth_time_source: "period_only",
|
|
birth_time_period: "early_morning",
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
} as const;
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(
|
|
reportedExactProfile,
|
|
resolveAccountBirthTimeApplicationPatch(reportedExactProfile, periodDeclaration),
|
|
),
|
|
{ status: "reported", activeTime: null },
|
|
);
|
|
|
|
// An untouched application keeps the stored truth, including a legacy confirmed minute.
|
|
const confirmedProfile = {
|
|
...reportedExactProfile,
|
|
active_birth_time: "05:18:00",
|
|
birth_time_status: "confirmed",
|
|
} as const;
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(
|
|
confirmedProfile,
|
|
resolveAccountBirthTimeApplicationPatch(confirmedProfile, { district_code: "130407" }),
|
|
),
|
|
{ status: "confirmed", activeTime: "05:18" },
|
|
);
|
|
const legacyProfile = {
|
|
...reportedExactProfile,
|
|
birth_time: "05:18:00",
|
|
birth_time_status: null,
|
|
} as const;
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(
|
|
legacyProfile,
|
|
resolveAccountBirthTimeApplicationPatch(legacyProfile, { district_code: "130407" }),
|
|
),
|
|
{ status: "confirmed", activeTime: "05:18" },
|
|
);
|
|
assert.deepEqual(
|
|
resolveAppliedAccountBirthTime(null, resolveAccountBirthTimeApplicationPatch(null, { name: "岳辰" })),
|
|
{ status: null, activeTime: null },
|
|
);
|
|
|
|
assert.match(source, /birthTime: resolveAppliedAccountBirthTime\(currentProfile, applicationPatch\)/);
|
|
});
|
|
|
|
test("only a strict family exact zero-uncertainty declaration is auto-accepted", () => {
|
|
const base = {
|
|
birth_date: "1997-08-08",
|
|
reported_birth_time: "05:00",
|
|
birth_time_source: "family_exact",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
} as const;
|
|
const declarations = [
|
|
{ ...base, uncertainty_before_minutes: 5, uncertainty_after_minutes: 5 },
|
|
{ ...base, uncertainty_before_minutes: 10, uncertainty_after_minutes: 10 },
|
|
{ ...base, uncertainty_before_minutes: 15, uncertainty_after_minutes: 15 },
|
|
{ ...base, birth_time_source: "approximate", uncertainty_before_minutes: 30, uncertainty_after_minutes: 30 },
|
|
{
|
|
...base,
|
|
reported_birth_time: null,
|
|
birth_time_source: "period_only",
|
|
birth_time_period: "morning",
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
},
|
|
{
|
|
...base,
|
|
reported_birth_time: null,
|
|
birth_time_source: "unknown",
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
},
|
|
] as const;
|
|
|
|
for (const declaration of declarations) {
|
|
assert.deepEqual(resolveAccountBirthTimeApplicationPatch(null, declaration), {
|
|
active_birth_time: null,
|
|
birth_time_status: "reported",
|
|
rectification_case_id: null,
|
|
});
|
|
}
|
|
});
|
|
|
|
test("reported birth-time status repair is forward-only and wired into production migration flow", () => {
|
|
assert.match(reportedStatusMigration, /birth_time_status is null/);
|
|
assert.match(reportedStatusMigration, /birth_time_status = 'reported'/);
|
|
assert.match(reportedStatusMigration, /active_birth_time is null/);
|
|
assert.match(reportedStatusMigration, /rectification_case_id is null/);
|
|
assert.equal(
|
|
productionMigrationWorkflow.match(/20260726010000_backfill_reported_birth_time_status\.sql/g)?.length,
|
|
2,
|
|
);
|
|
});
|
|
|
|
test("existing exact family declarations are forward-repaired without claiming confirmation", () => {
|
|
assert.match(acceptedExactFamilyMigration, /update public\.profiles/);
|
|
assert.match(acceptedExactFamilyMigration, /active_birth_time = reported_birth_time/);
|
|
assert.match(acceptedExactFamilyMigration, /birth_time_status = 'accepted'/);
|
|
assert.match(acceptedExactFamilyMigration, /birth_time_source = 'family_exact'/);
|
|
assert.match(acceptedExactFamilyMigration, /uncertainty_before_minutes = 0/);
|
|
assert.match(acceptedExactFamilyMigration, /uncertainty_after_minutes = 0/);
|
|
assert.match(acceptedExactFamilyMigration, /birth_time_status = 'reported'/);
|
|
assert.match(acceptedExactFamilyMigration, /active_birth_time is null/);
|
|
assert.match(acceptedExactFamilyMigration, /rectification_case_id is null/);
|
|
assert.doesNotMatch(acceptedExactFamilyMigration, /birth_time_status = 'confirmed'/);
|
|
assert.equal(
|
|
existsSync(new URL("../db/migrations/20260816010000_accept_exact_family_birth_times.sql", import.meta.url)),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test("account PATCH uses the shared validator and never writes client birth_time over account truth", () => {
|
|
assert.match(source, /accountProfilePatchSchema\.safeParse/);
|
|
assert.match(source, /resolveAccountBirthTimeApplicationPatch/);
|
|
assert.match(patchSource, /birthTimeSource[\s\S]*birth_time_status: "reported"/);
|
|
assert.doesNotMatch(source, /birth_time:\s*nullableString\(payload\.birth_time\)/);
|
|
assert.match(source, /invalidatesUnconfirmedApplication/);
|
|
assert.match(patchSource, /"birth_time_status"/);
|
|
assert.match(patchSource, /"active_birth_time"/);
|
|
assert.match(source, /latitude,longitude,timezone_offset/);
|
|
assert.match(source, /birth_place_label,birth_place_type,birth_place_provider,birth_place_provider_id,timezone_id,timezone_source/);
|
|
assert.match(source, /applyAccountProfileConcurrencyGuards/);
|
|
assert.match(source, /最新确认结果已保留/);
|
|
});
|
|
|
|
test("candidate invalidation compares coordinates and timezone in the conditional write", async () => {
|
|
const { applyAccountProfileConcurrencyGuards } = await import("../src/lib/account-profile-patch.ts");
|
|
const calls: Array<["eq" | "is", string, unknown]> = [];
|
|
const query = {
|
|
eq(column: string, value: unknown) {
|
|
calls.push(["eq", column, value]);
|
|
return this;
|
|
},
|
|
is(column: string, value: null) {
|
|
calls.push(["is", column, value]);
|
|
return this;
|
|
},
|
|
};
|
|
const current = {
|
|
birth_date: "1997-08-08",
|
|
reported_birth_time: "05:30",
|
|
birth_time_source: "approximate",
|
|
birth_time_period: null,
|
|
birth_time_clue: null,
|
|
uncertainty_before_minutes: 30,
|
|
uncertainty_after_minutes: 30,
|
|
active_birth_time: "05:18",
|
|
birth_time: "05:18",
|
|
birth_time_status: "candidate",
|
|
rectification_case_id: "11111111-1111-4111-8111-111111111111",
|
|
country_code: "CN",
|
|
province_code: "130000",
|
|
city_code: "130400",
|
|
district_code: "130406",
|
|
latitude: 36.420487,
|
|
longitude: 114.209936,
|
|
timezone_offset: 8,
|
|
};
|
|
|
|
applyAccountProfileConcurrencyGuards(query, current);
|
|
|
|
assert.deepEqual(calls.filter((call) => ["latitude", "longitude", "timezone_offset"].includes(call[1])), [
|
|
["eq", "latitude", 36.420487],
|
|
["eq", "longitude", 114.209936],
|
|
["eq", "timezone_offset", 8],
|
|
]);
|
|
assert.deepEqual(calls.find((call) => call[1] === "active_birth_time"), ["eq", "active_birth_time", "05:18"]);
|
|
assert.deepEqual(calls.find((call) => call[1] === "birth_time_status"), ["eq", "birth_time_status", "candidate"]);
|
|
});
|