Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/modules/i18n/locale-coherence.test.ts
T
2026-07-08 16:15:37 +02:00

428 lines
24 KiB
TypeScript

import { describe, expect, it } from "vitest";
import { readRepoFile } from "~/utils/testing/repoPaths";
function readTranslations(locale: "de" | "en") {
return JSON.parse(readRepoFile(`apps/web/public/locales/${locale}/translations.json`)) as {
models: {
contract: { name: string };
entity: { danger: { deleteRowsSuperAdminOnly_one: string; deleteRowsSuperAdminOnly_other: string } };
permission: { defaultPermissions: { actions: { users: string }; scopes: { "admin.roles": string; "admin.users": string } } };
role: { adminRoles: string };
row: { import: { defaultTag: string; mapFieldsFor: string; primary: string; errors: Record<string, string> } };
site: { placeholders: { siteId: string }; errors: { siteIdTaken: string } };
subscriptionProduct: { object: string; plural: string };
log: { actions: { workspaceRoleCreated: string; workspaceRoleUpdated: string; workspaceRoleDeleted: string } };
};
analytics: { content: string; medium: string; via: string };
app: {
navbar: { tenant: string };
sidebar: { featureFlags: string };
dashboard: { modules: { priorityInsights: { description: string }; subscriptionHealth: { description: string } } };
};
shared: { adminAccess: string; goBackToAdmin: string };
admin: {
users: {
errors: { cannotChangeAdminPassword: string; cannotRemoveLastAdmin: string; cannotRemoveOwnSuperAdmin: string };
};
marketingLeads: {
detail: { confirmCreateTenant: string; convertToTenant: string; convertedToTenant: string; tenantName: string };
errors: { conversionDisabled: string };
};
crm: {
sync: {
actions: { noUsers: string; createdAndUpdatedContacts: string };
sources: { user: string };
table: { user: string };
};
};
};
chat: {
assistant: { tenant: { name: string } };
errors: { adminRequired: string };
stream: { errors: { providerMissing: string } };
tools: { admin: { descriptions: { navigate: string }; schema: { section: string } } };
};
settings: {
forms: { visibility: { accountUsers: string } };
notifications: { description: string };
policies: {
description: string;
eyebrow: string;
heading: string;
resolvedWorkspace: string;
sections: { membership: { body: string } };
};
plugins: {
capabilities: string;
capabilityNames: { log: string; audit: string; secret_read: string; tenant_info: string; unknown: string };
consent: { available: string; reviewCapability: string };
audit: { filters: { capability: string }; table: { capability: string } };
settings: { description: string; errors: { settings_value_invalid: string } };
};
};
docs: { title: string; sidebar: { account: string; tenant: string; tenantSubscription: string; tenantUser: string } };
knowledgeBase: { layouts: { docs: string } };
ai: {
generations: {
actions: { prompt: string };
details: { userPrompt: string; fullPrompt: string };
errors: { promptRequired: string };
};
usage: { capability: string; capabilityBreakdown: string; capabilities: { unknown: string } };
elements: { context: { reasoning: string } };
};
pages: { adminCrm: { columns: { users: string } } };
prompts: { builder: { templateEditor: { maxTokens: string } } };
notifications: {
admin: {
messageTemplates: { "admin-users": string };
channelLabels: { "admin-users": string };
channelDescriptions: { "admin-users": string };
roleLabels: { SuperAdmin: string };
};
};
events: {
names: {
user_profile_updated: string;
user_profile_deleted: string;
user_password_updated: string;
user_preferences_updated: string;
};
};
featureFlags: {
empty: { demo: string };
engine: { description: string; errors: { invalidBooleanValue: string; invalidStringArray: string } };
};
workflows: {
validation: { allNodesValid: string; nodes: string };
blocks: { editor: { loopNext: string } };
defaultTemplates: {
sampleHttpRequests: { workflows: { getJsonPlaceholderTodoItem: { name: string; description: string } } };
aiProviderWorkflows: {
workflows: {
gptSimulator: { description: string; blocks: { if: { description: string }; log: { description: string; input: { message: string } } } };
};
};
};
};
};
}
function readSettings(locale: "de" | "en") {
return JSON.parse(readRepoFile(`apps/web/public/locales/${locale}/settings.json`)) as {
"tenant.theme.editor.cssParseFailed": string;
"tenant.theme.sidebar.title": string;
"tenant.theme.sidebar.description": string;
"tenant.theme.sidebar.forceDark": string;
"tenant.theme.sidebar.theme": string;
"tenant.theme.sidebar.styleOptions.sidebar": string;
"tenant.theme.tokens.sidebar": string;
"tenant.theme.tokens.sidebarBackground": string;
};
}
function readAuth(locale: "de" | "en") {
return JSON.parse(readRepoFile(`apps/web/public/locales/${locale}/auth.json`)) as {
errors: { passwordlessAccountUseMagicLink: string };
invitation: { skipPasswordUseMagicLink: string };
passwordPolicyBanner: { title: string; body: string };
};
}
function getTranslation(source: unknown, path: string[]) {
return path.reduce<unknown>((current, key) => (current && typeof current === "object" ? (current as Record<string, unknown>)[key] : undefined), source);
}
describe("locale coherence", () => {
it("keeps obvious cross-language copy leaks out of the English catalog", () => {
const en = readTranslations("en");
expect(en.models.contract.name).toBe("Name");
expect(en.models.contract.name).not.toBe("Nombre");
expect(en.models.site.errors.siteIdTaken).toContain("Site slug");
expect(en.models.site.errors.siteIdTaken).not.toContain("Site ID");
});
it("uses coherent German product language for imports and workflows", () => {
const de = readTranslations("de");
const settingsDe = readSettings("de");
const authDe = readAuth("de");
const importErrors = de.models.row.import.errors;
expect(importErrors.mappingMustBeObject).toContain("Zuordnung");
expect(importErrors.fieldMustBeObject).toContain("Feld");
expect(importErrors.rowValuesMustBeObject).toContain("Die Werte von Datensatz");
expect(importErrors.rowValueMustBeScalar).not.toContain("rows[");
expect(de.models.row.import.defaultTag).toBe("importiert");
expect(de.models.row.import.mapFieldsFor).toBe("Feldzuordnung");
expect(de.models.row.import.primary).toBe("Abgleichsfeld");
expect(de.models.site.placeholders.siteId).toBe("meine-website");
expect(de.models.site.errors.siteIdTaken).toContain("Website-Slug");
expect(de.models.subscriptionProduct.object).toBe("Tarif");
expect(de.models.subscriptionProduct.plural).toBe("Tarife");
expect(de.analytics.content).toBe("Inhalt");
expect(de.analytics.medium).toBe("Kanal");
expect(de.analytics.via).toBe("Zugriff über");
expect(de.app.navbar.tenant).toBe("Konto");
expect(de.app.navbar.tenant).not.toBe("Tenant");
expect(de.docs.title).toBe("Dokumentation");
expect(de.knowledgeBase.layouts.docs).toBe("Dokumentation");
expect(de.ai.generations.actions.prompt).toBe("Prompt");
expect(de.ai.generations.details.userPrompt).toBe("Nutzerprompt");
expect(de.ai.generations.details.fullPrompt).toBe("Vollständiger Prompt");
expect(de.ai.generations.errors.promptRequired).toBe("Prompt ist erforderlich.");
expect(de.ai.elements.context.reasoning).toBe("Schlussfolgerung");
expect(de.chat.assistant.tenant.name).toBe("Konto-Assistent");
expect(de.chat.errors.adminRequired).toBe("Admin-Zugriff erforderlich");
expect(de.chat.stream.errors.providerMissing).toContain("API-Schlüssel für den KI-Anbieter");
expect(de.chat.tools.admin.descriptions.navigate).toContain("Admin-Bereichen");
expect(de.chat.tools.admin.schema.section).toContain("Admin-Bereich");
expect(de.shared.adminAccess).toBe("Admin-Zugriff");
expect(de.shared.goBackToAdmin).toContain("Admin-Bereich");
expect(de.admin.marketingLeads.errors.conversionDisabled).toContain("Umwandlung von Leads in Konten");
expect(de.admin.users.errors.cannotChangeAdminPassword).toContain("Admin-Nutzers");
expect(de.admin.users.errors.cannotRemoveLastAdmin).toContain("Admin-Nutzer");
expect(de.admin.users.errors.cannotRemoveLastAdmin).toContain("Admin-Zugriff");
expect(de.admin.users.errors.cannotRemoveOwnSuperAdmin).toContain("Superadmin-Zugriff");
expect(de.admin.crm.sync.actions.noUsers).toBe("Keine Nutzer für die Synchronisierung");
expect(de.admin.crm.sync.actions.createdAndUpdatedContacts).toBe("{{created}}; {{updated}}");
expect(de.admin.crm.sync.errors.providerFetchFailed).toContain("CRM-Anbieterdaten");
expect(de.admin.crm.sync.sources.user).toBe("Nutzer");
expect(de.admin.crm.sync.table.user).toBe("Nutzer");
expect(settingsDe["tenant.theme.sidebar.title"]).toBe("Seitenleisten-Darstellung");
expect(settingsDe["tenant.theme.editor.cssParseFailed"]).toContain("verarbeitet");
expect(settingsDe["tenant.theme.sidebar.description"]).toContain("Seitenleiste");
expect(settingsDe["tenant.theme.sidebar.forceDark"]).toBe("Dunkle Seitenleiste erzwingen");
expect(settingsDe["tenant.theme.sidebar.theme"]).toBe("Seitenleisten-Design");
expect(settingsDe["tenant.theme.sidebar.styleOptions.sidebar"]).toBe("Seitenleiste (voll)");
expect(settingsDe["tenant.theme.tokens.sidebar"]).toBe("Seitenleiste");
expect(settingsDe["tenant.theme.tokens.sidebarBackground"]).toBe("Seitenleisten-Hintergrund");
expect(de.settings.forms.visibility.accountUsers).toBe("Kontomitglieder");
expect(de.workflows.validation.allNodesValid).toBe("Alle Blöcke sind gültig");
expect(de.workflows.validation.nodes).toBe("Blockvalidierung");
expect(de.workflows.defaultTemplates.sampleHttpRequests.workflows.getJsonPlaceholderTodoItem.name).toBe("JSONPlaceholder-Aufgabe abrufen");
expect(de.workflows.defaultTemplates.sampleHttpRequests.workflows.getJsonPlaceholderTodoItem.description).not.toContain("Wenn-");
expect(de.workflows.defaultTemplates.aiProviderWorkflows.workflows.gptSimulator.description).not.toContain("GPT-API");
expect(de.workflows.defaultTemplates.aiProviderWorkflows.workflows.gptSimulator.blocks.if.description).toContain("„bye“");
expect(de.workflows.defaultTemplates.aiProviderWorkflows.workflows.gptSimulator.blocks.log.input.message).toContain("„bye“");
expect(de.app.sidebar.featureFlags).toBe("Feature-Flags");
expect(de.app.dashboard.modules.subscriptionHealth.description).toContain("Durch Feature-Flags");
expect(de.ai.usage.capability).toBe("KI-Funktion");
expect(de.ai.usage.capabilityBreakdown).toBe("Kosten nach KI-Funktion");
expect(de.ai.usage.capabilities.unknown).toBe("Unbekannte KI-Funktion ({{capability}})");
for (const value of [de.ai.usage.capability, de.ai.usage.capabilityBreakdown, de.ai.usage.capabilities.unknown]) {
expect(value.replace(/\{\{[^}]+}}/g, ""), value).not.toMatch(/\bCapabilit(?:y|ies)\b/);
}
expect(de.models.entity.danger.deleteRowsSuperAdminOnly_one).toContain("nur Superadmin");
expect(de.models.entity.danger.deleteRowsSuperAdminOnly_other).toContain("nur Superadmin");
expect(de.models.role.adminRoles).toBe("Admin-Rollen");
expect(de.models.permission.defaultPermissions.actions.users).toBe("Nutzer");
expect(de.models.permission.defaultPermissions.scopes["admin.roles"]).toBe("Admin-Rollen");
expect(de.models.permission.defaultPermissions.scopes["admin.users"]).toBe("Admin-Nutzer");
expect(de.pages.adminCrm.columns.users).toBe("Nutzer");
expect(de.prompts.builder.templateEditor.maxTokens).toBe("Max. Token");
expect(de.notifications.admin.messageTemplates["admin-users"]).toBe("Admin-Nutzer");
expect(de.notifications.admin.channelLabels["admin-users"]).toBe("Admin-Nutzer");
expect(de.notifications.admin.channelDescriptions["admin-users"]).toBe("Nutzerprofil aktualisiert");
expect(de.notifications.admin.roleLabels.SuperAdmin).toBe("Superadmin");
expect(de.events.names.user_profile_updated).toBe("Nutzerprofil aktualisiert");
expect(de.events.names.user_profile_deleted).toBe("Nutzerprofil gelöscht");
expect(de.events.names.user_password_updated).toBe("Nutzerpasswort aktualisiert");
expect(de.events.names.user_preferences_updated).toBe("Nutzereinstellungen aktualisiert");
expect(de.settings.plugins.capabilityNames.log).toBe("Protokollierung");
expect(de.settings.plugins.capabilityNames.audit).toBe("Audit-Protokollierung");
expect(de.settings.plugins.capabilityNames.tenant_info).toBe("Kontoinformationen");
expect(de.settings.plugins.capabilityNames.secret_read).toBe("Geheime Werte lesen");
expect(de.settings.plugins.capabilities).toBe("Plugin-Berechtigungen");
expect(de.settings.plugins.capabilityNames.unknown).toBe("Unbekannte Plugin-Berechtigung ({{capability}})");
expect(de.settings.plugins.consent.reviewCapability).toContain("Plugin-Berechtigung");
expect(de.settings.plugins.consent.available).toBe("In dieser Laufzeit verfügbar");
expect(de.settings.plugins.audit.filters.capability).toBe("Plugin-Berechtigung");
expect(de.settings.plugins.audit.table.capability).toBe("Plugin-Berechtigung");
expect(de.settings.plugins.settings.errors.settings_value_invalid).toContain("als JSON speicherbar");
expect(de.settings.plugins.settings.description).toContain("API-Schlüssel");
expect(de.settings.plugins.settings.description).not.toContain("API-Key-Bezug");
expect(de.settings.notifications.description).toContain("Kontoaktualisierungen");
expect(de.settings.notifications.description).not.toContain("Konto-Aktualisierungen");
expect(de.settings.policies.description).toContain("schreibgeschützte Übersicht");
expect(de.settings.policies.eyebrow).toBe("Status der Kontorichtlinien");
expect(de.settings.policies.heading).toBe("Kontorichtlinien");
expect(de.settings.policies.resolvedWorkspace).toBe("Aktuelles Konto:");
expect(de.settings.policies.sections.membership.body).toContain("Mitgliedschaften");
expect(de.settings.policies.sections.membership.body).not.toContain("Konto-Mitgliedschaften");
expect(de.models.log.actions.workspaceRoleCreated).toBe("Kontorolle erstellt");
expect(de.models.log.actions.workspaceRoleUpdated).toBe("Kontorolle aktualisiert");
expect(de.models.log.actions.workspaceRoleDeleted).toBe("Kontorolle gelöscht");
expect(de.workflows.blocks.editor.loopNext).toBe("Nächster Schleifendurchlauf");
expect(authDe.passwordPolicyBanner.title).toContain("Sicherheitsrichtlinie");
expect(authDe.passwordPolicyBanner.body).toContain("Passwortanforderungen");
expect(authDe.passwordPolicyBanner.title).not.toContain("Sicherheits-Richtlinie");
expect(authDe.passwordPolicyBanner.body).not.toContain("Passwort-Anforderungen");
expect(authDe.errors.passwordlessAccountUseMagicLink).toContain("per Magic Link");
expect(authDe.invitation.skipPasswordUseMagicLink).toContain("Magic Link");
expect(de.featureFlags.empty.demo).toContain("prüfe");
expect(de.featureFlags.engine.description).toContain("Zielgruppenregeln");
expect(de.featureFlags.engine.errors.invalidBooleanValue).toContain("boolescher Wert");
expect(de.featureFlags.engine.errors.invalidStringArray).toContain("Liste von Zeichenketten");
const userCopyPaths = [
["shared", "invalidUser"],
["shared", "setUserRoles"],
["shared", "anonymousUser"],
["app", "sidebar", "accountsAndUsers"],
["app", "users", "selectAtLeastOne"],
["app", "users", "select"],
["app", "users", "empty"],
["app", "users", "logs", "empty"],
["admin", "accounts", "subscriptionCustomer", "errors", "noUsers"],
["admin", "metrics", "columns", "user"],
["admin", "kpi", "activeUsers", "hint"],
["admin", "users", "confirmUpdatePassword"],
["admin", "users", "deleteWarning"],
["admin", "users", "create", "errors", "userAlreadyExists"],
["admin", "users", "create", "errors", "unexpectedCreateError"],
["models", "user", "object"],
["models", "user", "plural"],
["models", "role", "assignToNewUsers"],
["models", "role", "assignToNewUsersDescription"],
["models", "permission", "userRoles"],
["models", "permission", "userPermissions"],
["models", "view", "user"],
["models", "portal", "counts", "users_one"],
["models", "portal", "counts", "users_other"],
["settings", "notifications", "description"],
["settings", "policies", "sections", "notifications", "body"],
["settings", "danger", "deleteUserAccount"],
["settings", "danger", "deleteYourAccount"],
["settings", "members", "roles", "manage"],
["settings", "members", "groups", "createTitle"],
["settings", "members", "groups", "editTitle"],
["settings", "plugins", "settings", "description"],
["settings", "privacy", "delete", "title"],
["settings", "privacy", "admin", "description"],
["settings", "privacy", "admin", "reasonPlaceholder"],
["settings", "privacy", "admin", "messages", "exportRequested"],
["workflows", "blocks", "alertUser", "name"],
["workflows", "variables", "suggestions", "sessionUserEmail"],
["workflows", "defaultTemplates", "alertUser", "title"],
["workflows", "defaultTemplates", "alertUser", "workflows", "alertUser", "name"],
["workflows", "defaultTemplates", "aiProviderWorkflows", "workflows", "gptSimulator", "description"],
["pricing", "planForm", "fields", "publicDescription"],
["pricing", "planForm", "fields", "billingAddressCollectionDescription"],
["pricing", "planForm", "fields", "canBuyAgainDescription"],
["pricing", "features", "users", "one"],
["pricing", "features", "users", "max"],
["pricing", "features", "users", "monthly"],
["pricing", "features", "users", "unlimited"],
["pricing", "features", "users", "moreThan"],
["pricing", "features", "users", "enterprise"],
["account", "invitation", "anotherEmail"],
["models", "entity", "form", "descriptions", "hasApi"],
["docs", "sidebar", "user"],
["docs", "sidebar", "tenantUser"],
["cookies", "items", "session", "description"],
["shell", "profile", "userMenu"],
["api", "errors", "existingUser"],
["api", "errors", "maxNumberOfUsers"],
["api", "errors", "userNotRegistered"],
["api", "errors", "userAlreadyRegistered"],
["api", "errors", "userAlreadyRegisteredEmailSent"],
["api", "errors", "userAlreadyVerified"],
["onboarding", "block", "samples", "welcome", "description"],
["onboarding", "block", "samples", "filters", "description"],
["onboarding", "block", "samples", "inputs", "description"],
["onboarding", "block", "samples", "activity", "description"],
["onboarding", "notices", "activeVisible"],
["onboarding", "object", "empty", "description"],
["onboarding", "session", "user"],
["onboarding", "filter", "description"],
["onboarding", "filter", "realtime", "description"],
["onboarding", "filter", "candidates", "description"],
["onboarding", "filter", "empty", "description"],
["onboarding", "filter", "empty", "allUsersCandidates"],
];
for (const path of userCopyPaths) {
const value = getTranslation(de, path);
expect(value, path.join(".")).toEqual(expect.stringContaining("Nutzer"));
expect(value, path.join(".")).not.toContain("Benutzer");
}
expect(getTranslation(de, ["admin", "users", "setAdminRoles"])).toBe("Admin-Rollen festlegen");
});
it("keeps account wording coherent in English plugin copy", () => {
const en = readTranslations("en") as ReturnType<typeof readTranslations> & {
settings: {
plugins: {
description: string;
capabilities: string;
empty: string;
capabilityNames: { tenant_info: string; unknown: string };
consent: { reviewCapabilities: string; reviewCapability: string };
audit: { heading: string; filters: { capability: string }; table: { capability: string } };
errors: { lifecycle: { tenant_install_limit_exceeded: string } };
};
notifications: { description: string };
danger: { deleteWorkspace: string };
subscription: { errors: { invalidTenant: string }; checkout: { tenantMismatch: string } };
members: { errors: { tenantOrUserNotFound: string } };
};
workflows: { variables: { suggestions: { sessionTenantId: string } } };
};
expect(en.settings.plugins.description).toContain("account plugins");
expect(en.settings.plugins.description).toContain("plugin capabilities");
expect(en.settings.plugins.capabilities).toBe("Plugin capabilities");
expect(en.settings.plugins.empty).toContain("this account");
expect(en.settings.plugins.capabilityNames.tenant_info).toBe("Account info");
expect(en.settings.plugins.capabilityNames.unknown).toBe("Unknown plugin capability ({{capability}})");
expect(en.settings.plugins.consent.reviewCapabilities).toBe("Review plugin capabilities");
expect(en.settings.plugins.consent.reviewCapability).toContain("plugin capability");
expect(en.settings.plugins.audit.heading).toBe("Plugin capability invocations");
expect(en.settings.plugins.audit.filters.capability).toBe("Plugin capability");
expect(en.settings.plugins.audit.table.capability).toBe("Plugin capability");
expect(en.settings.plugins.errors.lifecycle.tenant_install_limit_exceeded).toContain("this account");
expect(en.settings.plugins.description).not.toContain("workspace");
expect(en.settings.notifications.description).toContain("current account");
expect(en.settings.notifications.description).not.toContain("workspace");
expect(en.settings.danger.deleteWorkspace).toBe("Delete account");
expect(en.settings.subscription.errors.invalidTenant).toContain("Invalid account");
expect(en.settings.subscription.checkout.tenantMismatch).toContain("Account mismatch");
expect(en.settings.members.errors.tenantOrUserNotFound).toContain("account or user");
expect(en.workflows.variables.suggestions.sessionTenantId).toBe("Account ID");
});
it("keeps account wording coherent in visible English account surfaces", () => {
const en = readTranslations("en");
expect(en.admin.marketingLeads.detail.confirmCreateTenant).toContain("new account");
expect(en.admin.marketingLeads.detail.convertToTenant).toBe("Convert to account");
expect(en.admin.marketingLeads.detail.convertedToTenant).toContain("Converted to account");
expect(en.admin.marketingLeads.detail.tenantName).toBe("Account name");
expect(en.docs.sidebar.account).toBe("Account");
expect(en.docs.sidebar.tenant).toBe("Account");
expect(en.docs.sidebar.tenantSubscription).toBe("Account Subscription");
expect(en.docs.sidebar.tenantUser).toBe("Account User");
expect(en.app.dashboard.modules.priorityInsights.description).toContain("accounts with priority features");
expect(en.app.dashboard.modules.priorityInsights.description).not.toContain("tenants with priority features");
const visibleAccountCopy = [
en.admin.marketingLeads.detail.confirmCreateTenant,
en.admin.marketingLeads.detail.convertToTenant,
en.admin.marketingLeads.detail.convertedToTenant,
en.admin.marketingLeads.detail.tenantName,
en.docs.sidebar.account,
en.docs.sidebar.tenant,
en.docs.sidebar.tenantSubscription,
en.docs.sidebar.tenantUser,
];
for (const value of visibleAccountCopy) {
expect(value.replace(/\{\{[^}]+}}/g, ""), value).not.toMatch(/\b[Tt]enants?\b/);
}
});
});