Make the sample index gates fail when they should

Five tests asserted things that could not come out any other way, so the gate
they belonged to was reporting a pass it had not earned.

Three of them asked the in-memory object a question about the published file:
the schema version and source restated their own field initializers, the
language tag restated the line in IndexGenerator that sets it, and the keyword
check restated the TrimEntries already applied by SplitKeywords. They now read
the committed JSON, which is what a consumer fetches and the only place the
serialized field names can be observed. The keyword gate also covers the
generated keywords, which come from the category frontmatter by a different path
and were not checked at all, and the trimming it relies on is now pinned by unit
tests over messy frontmatter.

The fourth asserted that generating twice in one process produced the same
bytes, which cannot see the divergence it was written to prevent: the index is
generated on Windows and byte-compared by a Linux CI job, and NTFS compares
names case-insensitively where ext4 does not. A fixture whose ordinal and
case-insensitive orderings disagree catches both halves of that — dropping the
sort, and swapping the comparer — on either filesystem. The existing
EntriesAreOrderedByDocumentPath cannot, because every component in this
repository happens to start with a capital letter.

Program.cs had no coverage at all, while CI depends on its exit codes: 2 for a
mistyped command, 1 for a stale or missing index, 0 otherwise. A mistyped
command reported as drift would send someone looking for a change that was never
made. The CRLF normalization is covered too, since without it every Windows
working copy reads as stale.

Main becomes internal so the tests can call it, and the fixture repository they
run against lives in Fixture.cs.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Jaylyn-Barbee

tools/SampleIndexExporter.Tests/ContractConformanceTests.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Text.Json;
 using System.Text.RegularExpressions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -21,8 +22,14 @@ public class ContractConformanceTests
     [TestMethod]
     public void IndexDeclaresItsSourceAndVersion()
     {
-        Assert.AreEqual(1, RepositoryIndex.Index.SchemaVersion);
-        Assert.AreEqual("toolkit", RepositoryIndex.Index.Source);
+        // Read back from the committed file rather than the object that produced it. A consumer
+        // branches on these two fields before it reads anything else, so what matters is that
+        // they survive serialization under the field names the contract publishes — asserting
+        // against the in-memory defaults would only restate their initializers.
+        using var document = JsonDocument.Parse(RepositoryIndex.CommittedJson);
+
+        Assert.AreEqual(1, document.RootElement.GetProperty("schemaVersion").GetInt32());
+        Assert.AreEqual("toolkit", document.RootElement.GetProperty("source").GetString());
     }
 
     [TestMethod]
@@ -134,19 +141,54 @@ public void EveryNuGetPackageNameLooksLikeAPackage()
     }
 
     [TestMethod]
-    public void CuratedKeywordsAreTrimmedAndNonEmpty()
+    public void KeywordsAreTrimmedAndNonEmpty()
     {
         // Consumers weight curated keywords above generated ones, so a stray empty string or
-        // untrimmed entry becomes a search term that matches nothing.
-        var malformed = RepositoryIndex.Index.Controls
-            .Where(c => c.CuratedKeywords is { } keywords
-                        && keywords.Any(k => string.IsNullOrWhiteSpace(k) || k != k.Trim()))
-            .Select(c => c.Id)
-            .ToList();
+        // untrimmed entry becomes a search term that matches nothing. Read back from the
+        // committed file, and covering both lists: the generated keywords come from the
+        // category frontmatter by a different path than the curated ones, and were not checked
+        // at all.
+        using var document = JsonDocument.Parse(RepositoryIndex.CommittedJson);
+
+        var malformed = new List<string>();
+
+        foreach (var control in document.RootElement.GetProperty("controls").EnumerateArray())
+        {
+            foreach (var field in new[] { "curatedKeywords", "keywords" })
+            {
+                if (!control.TryGetProperty(field, out var keywords))
+                {
+                    continue;
+                }
+
+                malformed.AddRange(keywords
+                    .EnumerateArray()
+                    .Select(k => k.GetString())
+                    .Where(k => string.IsNullOrWhiteSpace(k) || k != k.Trim())
+                    .Select(k => $"{control.GetProperty("id").GetString()}.{field}: '{k}'"));
+            }
+        }
 
         Assert.AreEqual(
             0,
             malformed.Count,
-            "Entries with blank or untrimmed curated keywords:\n  " + string.Join("\n  ", malformed));
+            "Blank or untrimmed keywords:\n  " + string.Join("\n  ", malformed));
+    }
+
+    [TestMethod]
+    public void KeywordSplittingDiscardsPaddingAndEmptyTerms()
+    {
+        // Pins the behaviour the gate above relies on. Frontmatter is hand-written, so a
+        // trailing comma or a space after one is a matter of time rather than a hypothetical.
+        var keywords = MarkdownDocument.SplitKeywords("WrapPanel,  Layout ,, Panel,");
+
+        CollectionAssert.AreEqual(new[] { "WrapPanel", "Layout", "Panel" }, keywords);
+    }
+
+    [TestMethod]
+    public void KeywordSplittingTreatsAnAbsentFieldAsNoKeywords()
+    {
+        Assert.AreEqual(0, MarkdownDocument.SplitKeywords(null).Count);
+        Assert.AreEqual(0, MarkdownDocument.SplitKeywords("   ").Count);
     }
 }

tools/SampleIndexExporter.Tests/Fixture.cs

@@ -0,0 +1,83 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.SampleIndex.Tests;
+
+/// <summary>
+/// Builds a miniature repository on disk for the tests that are about the exporter rather than
+/// about this repository's samples.
+/// </summary>
+/// <remarks>
+/// Small on purpose. It has to satisfy <see cref="IndexGenerator.FindRepoRoot"/> and carry one
+/// component with one documented sample; anything more would make the tests that use it harder
+/// to read without making them test more.
+/// </remarks>
+internal static class Fixture
+{
+    public const string SampleXaml =
+        """
+        <Page x:Class="Widgets.WidgetSample"
+              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+            <TextBlock Text="Hello" />
+        </Page>
+        """;
+
+    /// <summary>Create a fixture repository and return its root.</summary>
+    /// <param name="components">
+    /// Component folder names, created in the order given. The generated index must not depend
+    /// on that order.
+    /// </param>
+    public static string Create(params string[] components)
+    {
+        if (components.Length == 0)
+        {
+            components = ["Widgets"];
+        }
+
+        var root = Directory.CreateTempSubdirectory("sample-index-").FullName;
+
+        // What FindRepoRoot looks for.
+        File.WriteAllText(Path.Combine(root, "Directory.Build.props"), "<Project />");
+        Directory.CreateDirectory(Path.Combine(root, "components"));
+
+        foreach (var component in components)
+        {
+            var samples = Directory.CreateDirectory(
+                Path.Combine(root, "components", component, "samples")).FullName;
+
+            File.WriteAllText(Path.Combine(samples, $"{component}.md"), Document(component));
+            File.WriteAllText(Path.Combine(samples, "WidgetSample.xaml.cs"), Declaration("WidgetSample", "Widget"));
+            File.WriteAllText(Path.Combine(samples, "WidgetSample.xaml"), SampleXaml);
+        }
+
+        return root;
+    }
+
+    public static string Declaration(string id, string displayName) =>
+        $$"""
+        using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+        namespace Widgets;
+
+        [ToolkitSample(id: nameof({{id}}), "{{displayName}}", description: "Shows a widget.")]
+        public sealed partial class {{id}} : Page;
+        """;
+
+    private static string Document(string component) =>
+        $"""
+        ---
+        title: {component}
+        author: nobody
+        description: A component used by the exporter's own tests.
+        keywords: {component}
+        category: Controls
+        subcategory: Layout
+        ---
+
+        Prose introducing the sample.
+
+        > [!SAMPLE WidgetSample]
+        """;
+}

tools/SampleIndexExporter.Tests/IndexUpToDateTests.cs

@@ -46,15 +46,53 @@ public void CommittedIndexMatchesTheSamples()
     [TestMethod]
     public void GeneratingTwiceProducesTheSameBytes()
     {
-        // Stable ordering, stated as a test rather than assumed. If generation were order-
-        // dependent — on file enumeration order, say, or on a dictionary's iteration order —
-        // the staleness check above would fail at random and teach everyone to ignore it.
+        // Catches in-process non-determinism only: a dictionary's iteration order, a hash set
+        // reaching the output, a stray DateTime. It cannot see the filesystem-dependent kind,
+        // which is what the test below is for.
         var first = IndexGenerator.Serialize(IndexGenerator.Generate(RepositoryIndex.Root).Index);
         var second = IndexGenerator.Serialize(IndexGenerator.Generate(RepositoryIndex.Root).Index);
 
         Assert.AreEqual(first, second, "Generating the index twice produced different output.");
     }
 
+    [TestMethod]
+    public void EntriesAreOrderedOrdinallyRatherThanByTheHostsIdeaOfOrder()
+    {
+        // The index is generated by contributors on Windows and byte-compared by a Linux CI
+        // job, so every ordering has to mean the same thing on both. NTFS compares names
+        // case-insensitively and ext4 does not; a culture-aware or case-insensitive comparer
+        // would therefore agree with itself on one machine and disagree across the two,
+        // producing a CI failure nobody could reproduce locally.
+        //
+        // These three names are chosen so ordinal order (uppercase first) and case-insensitive
+        // order disagree: ordinal gives Beta, Gamma, alpha; case-insensitive gives alpha, Beta,
+        // Gamma. Comparing two fixtures built in different orders would not catch this, because
+        // NTFS hands directory entries back in name order whatever order they were created in.
+        var root = Fixture.Create("Beta", "alpha", "Gamma");
+
+        try
+        {
+            var entries = IndexGenerator.Generate(root).Index.Controls
+                .Select(c => c.Toolkit!.DocumentPath)
+                .ToList();
+
+            CollectionAssert.AreEqual(
+                new[]
+                {
+                    "components/Beta/samples/Beta.md",
+                    "components/Gamma/samples/Gamma.md",
+                    "components/alpha/samples/alpha.md",
+                },
+                entries,
+                "Entries must be ordered ordinally, which is the only order both CI and a "
+                    + "contributor's machine agree on.");
+        }
+        finally
+        {
+            Directory.Delete(root, recursive: true);
+        }
+    }
+
     [TestMethod]
     public void EntriesAreOrderedByDocumentPath()
     {