Hay-Grade statt Verwendungsgruppe A--F

A--F stammte aus der Spezifikation, nicht vom Kunden: sechs erfundene Stufen
mit erfundenen Beschreibungen. Der Kunde bewertet nach Hay und hat die Liste
geschickt -- 13 Stufen plus einen Generic Grade.

Dieselbe Spalte fuellt im Cornerstone-Extrakt die Grade ID. Solange dort A--F
steht, ist die Datei in jeder Zeile falsch, ohne dass es beim Erzeugen
auffaellt: das Zielsystem kennt diese Kennungen nicht.

Der Typ heisst weiter paygrade_type, ist aber jetzt eine Domain ueber text mit
CHECK statt eines Aufzaehlungstyps. Ein Enum laesst sich nicht umschreiben --
Werte entfernen geht gar nicht, und add value darf im selben Vorgang, der den
neuen Wert schreibt, nicht benutzt werden. Wichtiger: die rund zehn
SQL-Funktionen, die den Wert nach paygrade_type umwandeln, bleiben unveraendert
gueltig. Jede von ihnen neu zu erzeugen hiesse, zehnmal die Gelegenheit zu
haben, aus einer veralteten Vorlage zu kopieren.

Zwei Funktionen muessen doch angefasst werden, beide per Punktaenderung an der
laufenden Definition statt per Kopie aus einer Datei: der Vorgabewert B in
hire_employee und die Beschriftung im Protokoll von promote_employee.

Der Bestand bekommt den Generic Grade. Aus A--F liesse sich kein Hay-Grade
ableiten: andere Einteilung, andere Anzahl. Geraten saehe im Extrakt genauso
aus wie erhoben.

tests/unit/hay-grade.test.ts

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { HAY_GRADES, HAY_GRADE_STANDARD, HAY_GRADE_WERTE, hayGradeLabel, istHayGrade } from "@/lib/hay-grade";
+
+// Dieselbe Vorsichtsmassnahme wie bei Personenkreis und Mitarbeiterart: die
+// Liste steht in der Migration als CHECK und hier für die Oberfläche. Laufen
+// die beiden auseinander, bietet das Formular einen Wert an, den die Datenbank
+// abweist — und die Benutzerin sieht einen Fehler aus dem Maschinenraum.
+
+const MIGRATION = join(process.cwd(), "db/migrations/20260928140000_hay_grade.sql");
+
+function werteAusDerBedingung(): string[] {
+  const sql = readFileSync(MIGRATION, "utf8");
+  const block = sql.match(/constraint chk_hay_grade check \([\s\S]*?\);/)?.[0];
+  expect(block, "Die Bedingung steht nicht mehr in der Migration").toBeDefined();
+  return [...block!.matchAll(/'([^']+)'/g)].map((m) => m[1]);
+}
+
+describe("Die Hay-Grades", () => {
+  it("stimmen mit der Bedingung in der Datenbank überein", () => {
+    expect(new Set(werteAusDerBedingung())).toEqual(new Set(HAY_GRADE_WERTE));
+  });
+
+  it("führen den Generic Grade als Vorgabe", () => {
+    // Die Spalte ist NOT NULL mit genau diesem Vorgabewert, und der Bestand
+    // hat ihn bei der Umstellung bekommen. Weicht die Oberfläche davon ab,
+    // bekämen neue Zeilen etwas anderes als die vorhandenen.
+    expect(HAY_GRADE_WERTE).toContain(HAY_GRADE_STANDARD);
+    expect(readFileSync(MIGRATION, "utf8")).toContain("set default '-'");
+  });
+
+  it("zeigen den Titel und speichern die Kennung", () => {
+    // Nur beim Generic Grade gehen beide auseinander — genau deshalb darf die
+    // Anzeige nicht einfach der gespeicherte Wert sein.
+    expect(hayGradeLabel("-")).toBe("Generic Grade");
+    expect(hayGradeLabel("HG15")).toBe("HG15");
+    for (const g of HAY_GRADES) {
+      if (g.value !== "-") expect(g.label).toBe(g.value);
+    }
+  });
+
+  it("lassen einen unbekannten Wert stehen, statt ihn zu verschlucken", () => {
+    // Eine Zeile aus der Zeit vor der Umstellung soll sichtbar falsch sein,
+    // nicht unsichtbar leer.
+    expect(hayGradeLabel("B")).toBe("B");
+    expect(hayGradeLabel(null)).toBe("–");
+  });
+
+  it("weisen zurück, was nicht in der Liste steht", () => {
+    expect(istHayGrade("HG19P")).toBe(true);
+    expect(istHayGrade("HG21")).toBe(false);
+    expect(istHayGrade("B")).toBe(false);
+    expect(istHayGrade(null)).toBe(false);
+  });
+});

tests/unit/report-criteria.test.ts

@@ -16,15 +16,15 @@ function aus(params: Record<string, string>) {
 
 describe("parseCriteria", () => {
   it("nimmt bekannte Werte an", () => {
-    const c = aus({ employment: "Teilzeit", paygrade: "C", gender: "w" });
-    expect(c.auswahl).toEqual({ employment: "Teilzeit", paygrade: "C", gender: "w" });
+    const c = aus({ employment: "Teilzeit", paygrade: "HG13", gender: "w" });
+    expect(c.auswahl).toEqual({ employment: "Teilzeit", paygrade: "HG13", gender: "w" });
   });
 
   it("verwirft Werte, die nicht in der Liste stehen", () => {
     // Die Werte landen in SQL-Vergleichen und im Dateinamen des Downloads,
     // also in einem Content-Disposition-Header — was nicht in der Liste
     // steht, darf nicht durchkommen.
-    const c = aus({ employment: "Vollzeit'; drop table employees; --", paygrade: "Z", gender: "x" });
+    const c = aus({ employment: "Vollzeit'; drop table employees; --", paygrade: "HG21", gender: "x" });
     expect(c.auswahl).toEqual({});
   });
 

tests/unit/reports.test.ts

@@ -27,7 +27,7 @@ function emp(overrides: Partial<ReportEmployee> = {}): ReportEmployee {
     exit_date: null,
     weekly_hours: 38.5,
     source: "Extern",
-    paygrade: "B",
+    paygrade: "HG13",
     birth_date: "1990-01-01",
     gender: "w",
     worker_type: "Angestellte:r",