Forge

Jessie / forge public

Self-hosted git - made by qwen 3.8 27b

branch: main

Branches

main
LocalizationTests.cs 10.4 kB · 227 lines RawPermalinkHistory
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();
}

Keyboard shortcuts

/
Search repositories
s
Search file names and code
y
Open the permalink of the file being viewed
?
Show this help