123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
using System.Globalization;
using System.Net;
using System.Text.RegularExpressions;
using Forge.Localization;
using Forge.Tests.Support;
namespace Forge.Tests;
public partial class LocalizationTests(ForgeHost host) : IClassFixture<ForgeHost>
{
private static readonly Translations Translations = new();
private static readonly Localizer T = new(Translations);
private static TResult In<TResult>(string culture, Func<TResult> action)
{
var (ui, format) = (CultureInfo.CurrentUICulture, CultureInfo.CurrentCulture);
try
{
CultureInfo.CurrentUICulture = CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(culture);
return action();
}
finally
{
(CultureInfo.CurrentUICulture, CultureInfo.CurrentCulture) = (ui, format);
}
}
/// <summary>Every English text the code can display: T["…"], T.Html("…"), Localizer.Key("…") and T.Plural(n, "…", "…").</summary>
private static HashSet<string> KeysUsedInSource()
{
var keys = new HashSet<string>(StringComparer.Ordinal);
var files = Directory.EnumerateFiles(ForgeHost.WebProjectDirectory, "*.*", SearchOption.AllDirectories)
.Where(f => f.EndsWith(".razor", StringComparison.Ordinal) || f.EndsWith(".cs", StringComparison.Ordinal))
.Where(f => !f.Contains(Path.DirectorySeparatorChar + "obj" + Path.DirectorySeparatorChar)
&& !f.Contains(Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar));
foreach (var file in files)
{
var source = File.ReadAllText(file);
foreach (Match m in SingleKey().Matches(source))
{
keys.Add(Regex.Unescape(m.Groups[1].Value));
}
foreach (Match m in PluralKey().Matches(source))
{
keys.Add(m.Groups[1].Value + "|" + m.Groups[2].Value);
}
}
return keys;
}
[Fact]
public void English_is_first_and_slovak_is_available()
{
Assert.Equal("en", Translations.Languages[0]);
Assert.Contains("sk", Translations.Languages);
}
[Fact]
public void Every_language_translates_every_text_and_nothing_else()
{
var used = KeysUsedInSource();
Assert.True(used.Count > 150, $"Only {used.Count} keys found in the sources; the scan is probably broken.");
foreach (var language in Translations.Languages.Skip(1))
{
var translated = Translations.KeysOf(language).ToHashSet(StringComparer.Ordinal);
var missing = used.Except(translated).Order().ToList();
var unused = translated.Except(used).Order().ToList();
Assert.True(missing.Count == 0, $"{language}.json is missing:\n" + string.Join("\n", missing));
Assert.True(unused.Count == 0, $"{language}.json has entries the code does not use:\n" + string.Join("\n", unused));
}
}
[Fact]
public void Translations_keep_the_placeholders_of_the_english_text()
{
static string[] Placeholders(string text) =>
Placeholder().Matches(text).Select(m => m.Value).Distinct().Order().ToArray();
foreach (var language in Translations.Languages.Skip(1))
{
foreach (var key in Translations.KeysOf(language))
{
// A plural key is "one|other"; both halves carry the same placeholders.
var expected = Placeholders(key.Split('|')[^1]);
foreach (var form in Translations.Find(language, key)!)
{
Assert.True(expected.SequenceEqual(Placeholders(form)), $"{language}.json: \"{form}\" does not keep the placeholders of \"{key}\".");
}
}
}
}
[Fact]
public void Unknown_text_and_unknown_languages_fall_back_to_english()
{
Assert.Equal("Sign in", In("en", () => T["Sign in"]));
Assert.Equal("Prihlásiť sa", In("sk", () => T["Sign in"]));
Assert.Equal("Prihlásiť sa", In("sk-SK", () => T["Sign in"]));
Assert.Equal("Sign in", In("de-DE", () => T["Sign in"]));
Assert.Equal("Not a known text", In("sk", () => T["Not a known text"]));
Assert.Equal("sk", In("sk-SK", () => T.Language));
Assert.Equal("en", In("de-DE", () => T.Language));
Assert.Equal("Odhlásiť sa (jessie)", In("sk", () => T["Sign out ({0})", "jessie"]));
}
[Theory]
[InlineData(1, "1 line", "1 riadok")]
[InlineData(2, "2 lines", "2 riadky")]
[InlineData(4, "4 lines", "4 riadky")]
[InlineData(5, "5 lines", "5 riadkov")]
[InlineData(0, "0 lines", "0 riadkov")]
[InlineData(22, "22 lines", "22 riadkov")]
public void Plurals_follow_the_rules_of_each_language(int count, string english, string slovak)
{
Assert.Equal(english, In("en", () => T.Plural(count, "{0} line", "{0} lines")));
Assert.Equal(slovak, In("sk", () => T.Plural(count, "{0} line", "{0} lines")));
}
[Theory]
[InlineData(10, "just now", "práve teraz")]
[InlineData(60, "a minute ago", "pred minútou")]
[InlineData(60 * 5, "5 minutes ago", "pred 5 minútami")]
[InlineData(3600, "an hour ago", "pred hodinou")]
[InlineData(3600 * 3, "3 hours ago", "pred 3 hodinami")]
[InlineData(86400 + 3600, "yesterday", "včera")]
[InlineData(86400 * 3, "3 days ago", "pred 3 dňami")]
[InlineData(86400 * 45, "a month ago", "pred mesiacom")]
[InlineData(86400 * 100, "3 months ago", "pred 3 mesiacmi")]
[InlineData(86400 * 400, "a year ago", "pred rokom")]
[InlineData(86400 * 800, "2 years ago", "pred 2 rokmi")]
public void Relative_time_is_translated(int secondsAgo, string english, string slovak)
{
var now = new DateTimeOffset(2026, 1, 1, 12, 0, 0, TimeSpan.Zero);
Assert.Equal(english, In("en", () => T.RelativeTime(now.AddSeconds(-secondsAgo), now)));
Assert.Equal(slovak, In("sk", () => T.RelativeTime(now.AddSeconds(-secondsAgo), now)));
}
[Fact]
public async Task Pages_are_english_by_default_and_follow_the_browser_language()
{
await host.CreateUserAsync();
using var plain = host.CreateClient();
var english = await ForgeHost.TextAsync(await plain.GetAsync("/login"));
Assert.Contains("<html lang=\"en\">", english);
Assert.Contains("<h1>Sign in</h1>", english);
using var slovakBrowser = host.CreateClient();
slovakBrowser.DefaultRequestHeaders.AcceptLanguage.ParseAdd("sk-SK,sk;q=0.9,en;q=0.8");
var slovak = await ForgeHost.TextAsync(await slovakBrowser.GetAsync("/login"));
Assert.Contains("<html lang=\"sk\">", slovak);
Assert.Contains("<h1>Prihlásiť sa</h1>", slovak);
// A language Forge does not have falls back to English.
using var germanBrowser = host.CreateClient();
germanBrowser.DefaultRequestHeaders.AcceptLanguage.ParseAdd("de-DE,de;q=0.9");
Assert.Contains("<h1>Sign in</h1>", await ForgeHost.TextAsync(await germanBrowser.GetAsync("/login")));
// Messages produced by form handlers and by services are translated too.
var wrong = await ForgeHost.PostFormAsync(slovakBrowser, "/login", "login", new() { ["Username"] = "jessie", ["Password"] = "wrong password" });
Assert.Contains("Nesprávne meno alebo heslo.", await ForgeHost.TextAsync(wrong));
using var signedIn = await host.CreateSignedInClientAsync();
signedIn.DefaultRequestHeaders.AcceptLanguage.ParseAdd("sk");
var invalid = await ForgeHost.PostFormAsync(signedIn, "/new", "new-repo", new() { ["Name"] = "bad..name" });
Assert.Contains("Názov nesmie obsahovať „..“.", await ForgeHost.TextAsync(invalid));
// Error pages as well.
var missing = await slovakBrowser.GetAsync("/nobody/nothing");
Assert.Equal(HttpStatusCode.NotFound, missing.StatusCode);
Assert.Contains("Táto stránka neexistuje", await ForgeHost.TextAsync(missing));
}
[Fact]
public async Task Language_switcher_remembers_the_choice_over_the_browser_language()
{
await host.CreateUserAsync();
using var client = host.CreateClient();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-US,en;q=0.9");
var page = await client.GetStringAsync("/login?returnUrl=%2Fnew");
Assert.Contains("name=\"lang\" value=\"sk\"", page);
Assert.Contains("slovenčina", WebUtility.HtmlDecode(page));
var token = WebUtility.HtmlDecode(AntiforgeryToken().Match(page).Groups[1].Value);
var switched = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string>
{
["__RequestVerificationToken"] = token,
["lang"] = "sk",
["returnUrl"] = "/login?returnUrl=%2Fnew",
}));
Assert.Equal(HttpStatusCode.Redirect, switched.StatusCode);
Assert.Equal("/login?returnUrl=%2Fnew", switched.Headers.Location?.OriginalString);
// The cookie wins over Accept-Language from now on.
Assert.Contains("<h1>Prihlásiť sa</h1>", await ForgeHost.TextAsync(await client.GetAsync("/login")));
// An unsupported language is ignored, and the return address cannot leave the site.
var ignored = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string>
{
["__RequestVerificationToken"] = token,
["lang"] = "xx",
["returnUrl"] = "//evil.example",
}));
Assert.Equal("/", ignored.Headers.Location?.OriginalString);
Assert.Contains("<h1>Prihlásiť sa</h1>", await ForgeHost.TextAsync(await client.GetAsync("/login")));
// Without the antiforgery token the switch is refused.
var forged = await client.PostAsync("/language", new FormUrlEncodedContent(new Dictionary<string, string> { ["lang"] = "en" }));
Assert.Equal(HttpStatusCode.BadRequest, forged.StatusCode);
}
// "this[" covers the Localizer's own lookups (relative time).
[GeneratedRegex("""(?:\bT\[|\bthis\[|\bT\.Html\(|Localizer\.Key\()\s*"((?:[^"\\]|\\.)*)"\s*[\],)]""")]
private static partial Regex SingleKey();
[GeneratedRegex("""\bT\.Plural\([^,]+,\s*"([^"]*)",\s*"([^"]*)"\)""")]
private static partial Regex PluralKey();
[GeneratedRegex(@"\{\d+\}")]
private static partial Regex Placeholder();
[GeneratedRegex("name=\"__RequestVerificationToken\" value=\"([^\"]+)\"")]
private static partial Regex AntiforgeryToken();
}