Files
Khaemhat/tests/Khaemhat.Web.Tests/Shell/LocalizationRulesTests.cs
T
Alby96andClaude Opus 5.5 cf6f849cc1 feat: application shell, localized texts and user preferences (M3, part 1)
The pages built so far now live inside the shell of the mockups instead of the
M0 placeholder, every interface text comes from Resources/it-IT, and each user
keeps their own look and start page.

- Shell: top bar, collapsible side menu with fly-out sub-menus, status bar and
  tabs that keep each page alive (page type and route values per tab, so a tab
  never shows another page); at most 12 tabs, least-used clean tab evicted.
- One shortcut table with Alt variants for the combinations browsers keep
  (Ctrl+W, Ctrl+Tab, Ctrl+N); command palette for pages and commands.
- ITexts over embedded JSON; tests forbid literal texts in .razor components
  and check that every key used exists.
- User settings in sys_user_settings / user_settings; theme written on the
  server; profile page with live preview, start page, sessions and shortcuts.
- Home, coming-soon pages for later milestones, localized sign-in and error
  pages; ADR 0020; wiki, CHANGELOG, STATUS and data model updated.

Refs #25 #26 #31 #33

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 16:44:59 +01:00

274 lines
9.7 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Text;
using System.Text.RegularExpressions;
using Khaemhat.Application.Preferences;
using Khaemhat.Web.Shell;
namespace Khaemhat.Web.Tests.Shell;
/// <summary>
/// The rule of SPEC §1.9 and issue #33: components contain no literal interface texts, every text comes from
/// <c>Resources/it-IT/*.json</c>, and every key the code asks for exists.
/// </summary>
[TestClass]
public sealed partial class LocalizationRulesTests
{
// Words allowed as they are: the product name and the names of things that are not translated.
private static readonly HashSet<string> Allowed = new(StringComparer.Ordinal) { "Khaemhat" };
[TestMethod]
public void Components_ContainNoLiteralTexts()
{
var problems = new List<string>();
foreach (var file in ComponentFiles())
{
foreach (var text in LiteralTexts(File.ReadAllText(file)))
{
problems.Add(Path.GetRelativePath(Repository.Root, file) + ": " + text);
}
}
Assert.IsEmpty(problems, "Texts belong in Resources/it-IT/*.json:\n" + string.Join('\n', problems));
}
[TestMethod]
public void TheCheck_FindsLiteralTexts_AndLetsTheRestThrough()
{
const string page = """
@page "/x"
@inject Foo Bar
@* A comment with words is fine. *@
<h1>@T["Pages.X.Title"]</h1>
<p class="lead">Testo scritto a mano</p>
<button title="Chiudi" aria-label="@T["Common.Close"]">@T.Format("Pages.X.Count", items.Count(i => i > 0))</button>
<img alt="" src="x.svg" />
<span>@(a ? T["A"] : T["B"]) · @Model.Name</span>
<input placeholder="Cerca" />
@foreach (var item in Items.Where(i => i.Level > 2))
{
<li>@item.Name</li>
}
<span>&times; ● Khaemhat @Session.Company?.Code @if (n.Body is not null) {<br />}</span>
@code {
private string Text => "Un testo nel codice";
}
""";
var found = LiteralTexts(page).ToList();
CollectionAssert.AreEquivalent(new[] { "Testo scritto a mano", "title=\"Chiudi\"", "placeholder=\"Cerca\"" }, found);
}
[TestMethod]
public void EveryTextKeyInTheCode_Exists()
{
var missing = new List<string>();
foreach (var file in Directory.EnumerateFiles(Path.Combine(Repository.Root, "src", "Khaemhat.Web"), "*.*", SearchOption.AllDirectories)
.Where(f => (f.EndsWith(".razor", StringComparison.Ordinal) || f.EndsWith(".cs", StringComparison.Ordinal)) && !Repository.IsBuildOutput(f)))
{
foreach (Match match in KeyPattern().Matches(File.ReadAllText(file)))
{
var key = match.Groups[1].Value;
if (!key.EndsWith('.') && !ShellTests.Texts.Contains(key))
{
missing.Add(Path.GetFileName(file) + ": " + key);
}
}
}
Assert.IsEmpty(missing, string.Join('\n', missing));
}
[TestMethod]
public void KeysBuiltFromValues_Exist()
{
var keys = new List<string>();
keys.AddRange(Enum.GetValues<ThemeMode>().Select(v => "Pages.Profile.Theme." + v));
keys.AddRange(Enum.GetValues<Density>().Select(v => "Pages.Profile.Density." + v));
keys.AddRange(Enum.GetValues<StartPage>().Select(v => "Pages.Profile.Start." + v));
keys.AddRange(Enum.GetValues<ShortcutScope>().Select(v => "Pages.Profile.Shortcuts." + v));
keys.AddRange(UserPreferences.Accents.Select(a => "Pages.Profile.Accent." + a));
Assert.IsEmpty(keys.Where(k => !ShellTests.Texts.Contains(k)).ToList());
}
[TestMethod]
public void TextFiles_AvoidCharactersGiteaFlagsAsAmbiguous()
{
var folder = Path.Combine(Repository.Root, "src", "Khaemhat.Web", "Resources");
foreach (var file in Directory.EnumerateFiles(folder, "*.json", SearchOption.AllDirectories))
{
var text = File.ReadAllText(file);
foreach (var c in new[] { '–', '×', '−', '›' })
{
Assert.DoesNotContain(c.ToString(), text, Path.GetFileName(file) + " contains U+" + ((int)c).ToString("X4", System.Globalization.CultureInfo.InvariantCulture));
}
}
}
internal static IEnumerable<string> ComponentFiles() =>
Directory.EnumerateFiles(Path.Combine(Repository.Root, "src", "Khaemhat.Web", "Components"), "*.razor", SearchOption.AllDirectories)
.Where(f => !Repository.IsBuildOutput(f));
/// <summary>The literal texts of a component: text between tags and text attributes, once code and expressions are removed.</summary>
/// <param name="razor">The component source.</param>
/// <returns>The texts found.</returns>
internal static IEnumerable<string> LiteralTexts(string razor)
{
var markup = CommentPattern().Replace(razor, string.Empty);
var code = markup.IndexOf("@code", StringComparison.Ordinal);
if (code >= 0)
{
markup = markup[..code];
}
var lines = markup.Split('\n').Select(l => CodeLinePattern().IsMatch(l) ? string.Empty : l);
markup = StripExpressions(string.Join('\n', lines));
foreach (Match attribute in AttributePattern().Matches(markup))
{
if (HasWords(attribute.Groups[2].Value))
{
yield return attribute.Groups[1].Value + "=\"" + attribute.Groups[2].Value + "\"";
}
}
foreach (Match node in TextNodePattern().Matches(markup))
{
var text = node.Groups[1].Value.Trim();
if (HasWords(text))
{
yield return text;
}
}
}
private static bool HasWords(string text)
{
var words = WordPattern().Matches(EntityPattern().Replace(text, " ")).Select(m => m.Value).Where(w => !Allowed.Contains(w));
return words.Any();
}
// Removes Razor expressions: @T["..."], @T.Format(...), @(...), @item.Name, @Model.Items[0].Text...
private static string StripExpressions(string text)
{
var result = new StringBuilder(text.Length);
var i = 0;
while (i < text.Length)
{
if (text[i] != '@' || i + 1 >= text.Length)
{
result.Append(text[i++]);
continue;
}
i++;
if (text[i] == '(')
{
i = SkipBalanced(text, i);
continue;
}
var start = i;
while (i < text.Length && (char.IsLetterOrDigit(text[i]) || text[i] == '_'))
{
i++;
while (i < text.Length && text[i] is '[' or '(')
{
i = SkipBalanced(text, i);
}
// Member access, also null-conditional (?.) and null-forgiving (!.).
if (i + 2 < text.Length && text[i] is '?' or '!' && text[i + 1] == '.' && char.IsLetter(text[i + 2]))
{
i += 2;
}
else if (i + 1 < text.Length && text[i] == '.' && char.IsLetter(text[i + 1]))
{
i++;
}
}
// @if (...) { ... } written inside a line of markup: the condition is code.
if (text.AsSpan(start, i - start) is "if" or "foreach" or "for" or "while" or "switch")
{
while (i < text.Length && text[i] == ' ')
{
i++;
}
if (i < text.Length && text[i] == '(')
{
i = SkipBalanced(text, i);
}
}
}
return result.ToString();
}
private static int SkipBalanced(string text, int start)
{
var depth = 0;
var quote = '\0';
for (var i = start; i < text.Length; i++)
{
var c = text[i];
if (quote != '\0')
{
if (c == '\\')
{
i++;
}
else if (c == quote)
{
quote = '\0';
}
continue;
}
switch (c)
{
case '"' or '\'':
quote = c;
break;
case '(' or '[' or '{':
depth++;
break;
case ')' or ']' or '}':
depth--;
if (depth == 0)
{
return i + 1;
}
break;
}
}
return text.Length;
}
[GeneratedRegex(@"@\*.*?\*@", RegexOptions.Singleline)]
private static partial Regex CommentPattern();
// Lines of C#: directives, control flow, braces, local declarations and assignments inside code blocks.
[GeneratedRegex(@"^\s*(@(page|inject|using|attribute|layout|implements|inherits|namespace|rendermode|typeparam|foreach|for|if|switch|while|else)\b|@\{|\{|\}|(else|case|default|break|var|if|foreach|return)\b|[a-z_][A-Za-z0-9_.]*\s*(=[^=>]|\+\+|--)|(string|int|bool|long)\??\s)")]
private static partial Regex CodeLinePattern();
[GeneratedRegex("\\b(title|placeholder|alt|aria-label|label)=\"([^\"]*)\"")]
private static partial Regex AttributePattern();
[GeneratedRegex(@">([^<>]+)<")]
private static partial Regex TextNodePattern();
[GeneratedRegex(@"\p{L}{2,}")]
private static partial Regex WordPattern();
[GeneratedRegex(@"&[a-zA-Z]+;|&#\d+;")]
private static partial Regex EntityPattern();
[GeneratedRegex("\"((?:Shell|Pages|Auth|Common)\\.[A-Za-z0-9_.]+)\"")]
private static partial Regex KeyPattern();
}