Elm test - expand CLI to offer listing tests

Author: Viir

implement/Pine.Core.Tests/Elm/ElmTest/ElmTestTests.cs

@@ -36,6 +36,34 @@ public void No_Elm_test_modules_is_a_test_run_result()
     }
 
 
+    [Fact]
+    public void Listed_test_and_listing_equality_is_structural()
+    {
+        var first =
+            new ListedTest(
+                "tests/Tests.elm",
+                ["Root", "Group"],
+                "test name");
+
+        var second =
+            new ListedTest(
+                new string("tests/Tests.elm".ToCharArray()),
+                [new string("Root".ToCharArray()), new string("Group".ToCharArray())],
+                new string("test name".ToCharArray()));
+
+        first.Equals(second).Should().BeTrue();
+        (first == second).Should().BeTrue();
+        first.GetHashCode().Should().Be(second.GetHashCode());
+
+        var firstListing = new ElmTestRun.Listed([first]);
+        var secondListing = new ElmTestRun.Listed([second]);
+
+        firstListing.Equals(secondListing).Should().BeTrue();
+        (firstListing == secondListing).Should().BeTrue();
+        firstListing.GetHashCode().Should().Be(secondListing.GetHashCode());
+    }
+
+
     [Fact]
     public void Verify_elm_test_results_for_scenarios_from_files()
     {

implement/Pine.Core/Elm/Testing/ElmTestRunner.cs

@@ -28,7 +28,8 @@ public static class ElmTestRunner
     public static ElmTestRun CompileAndRunTests(
         string appDirectory,
         IPineVM? pineVm = null,
-        string? filter = null)
+        string? filter = null,
+        bool listTests = false)
     {
         appDirectory = Path.GetFullPath(appDirectory);
 
@@ -76,6 +77,7 @@ file.path[0] is "tests" &&
 
                     return
                         (file.path,
+                        filePathText: string.Join('/', file.path),
                         moduleName: moduleHeader.ModuleName,
                         moduleNameText: string.Join('.', moduleHeader.ModuleName));
                 })
@@ -121,15 +123,37 @@ file.path[0] is "tests" &&
                     "Did not find declaration '" + testModule.moduleNameText + ".suite'");
             }
 
-            DiscoverTests(suiteValue, path: [], discoveredTests);
+            DiscoverTests(
+                suiteValue,
+                filePath: testModule.filePathText,
+                descriptionPath: [],
+                discoveredTests);
         }
 
         if (filter is { } filterText)
         {
             discoveredTests.RemoveAll(
                 test =>
+                !test.FilePath.Contains(filterText, StringComparison.OrdinalIgnoreCase) &&
                 !test.Path.Any(
-                    name => name.Contains(filterText, StringComparison.OrdinalIgnoreCase)));
+                    pathItem =>
+                    pathItem.Contains(filterText, StringComparison.OrdinalIgnoreCase)));
+        }
+
+        if (listTests)
+        {
+            return
+                new ElmTestRun.Listed(
+                    [
+                    ..                    discoveredTests
+                    .Where(test => test.Kind is not DiscoveredTestKind.EmptyGroup)
+                    .Select(
+                        test =>
+                        new ListedTest(
+                            test.FilePath,
+                            [.. test.Path.SkipLast(1)],
+                            test.Path[^1]))
+                    ]);
         }
 
         var parseCache = new PineVMParseCache();
@@ -425,7 +449,8 @@ private static IntermediatePineVM CreatePineVm() =>
 
     private static void DiscoverTests(
         PineValue testValue,
-        IReadOnlyList<string> path,
+        string filePath,
+        IReadOnlyList<string> descriptionPath,
         List<DiscoveredTest> discoveredTests)
     {
         var (tag, arguments) = ParseTaggedValue(testValue);
@@ -436,7 +461,7 @@ private static void DiscoverTests(
                 throw new InvalidOperationException("Describe must contain two arguments");
 
             var groupName = ParseElmString(arguments.Span[0]);
-            var groupPath = path.Append(groupName).ToImmutableArray();
+            var groupPath = descriptionPath.Append(groupName).ToImmutableArray();
 
             if (arguments.Span[1] is not PineValue.ListValue children)
                 throw new InvalidOperationException("Describe children must be a list");
@@ -445,6 +470,7 @@ private static void DiscoverTests(
             {
                 discoveredTests.Add(
                     new DiscoveredTest(
+                        filePath,
                         groupPath,
                         DiscoveredTestKind.EmptyGroup,
                         Thunk: null));
@@ -453,7 +479,7 @@ private static void DiscoverTests(
             }
 
             foreach (var child in children.Items.Span)
-                DiscoverTests(child, groupPath, discoveredTests);
+                DiscoverTests(child, filePath, groupPath, discoveredTests);
 
             return;
         }
@@ -465,7 +491,8 @@ private static void DiscoverTests(
 
             discoveredTests.Add(
                 new DiscoveredTest(
-                    [.. path, ParseElmString(arguments.Span[0])],
+                    filePath,
+                    [.. descriptionPath, ParseElmString(arguments.Span[0])],
                     DiscoveredTestKind.Runnable,
                     arguments.Span[1]));
 
@@ -479,7 +506,8 @@ private static void DiscoverTests(
 
             discoveredTests.Add(
                 new DiscoveredTest(
-                    [.. path, ParseElmString(arguments.Span[0])],
+                    filePath,
+                    [.. descriptionPath, ParseElmString(arguments.Span[0])],
                     DiscoveredTestKind.Todo,
                     Thunk: null));
 
@@ -522,6 +550,7 @@ private enum DiscoveredTestKind
 
 
     private sealed record DiscoveredTest(
+        string FilePath,
         IReadOnlyList<string> Path,
         DiscoveredTestKind Kind,
         PineValue? Thunk);
@@ -1020,6 +1049,64 @@ public void Deconstruct(
 }
 
 
+/// <summary>
+/// Describes a discovered Elm test.
+/// </summary>
+public sealed record ListedTest
+{
+    /// <summary>
+    /// Creates a description of a discovered Elm test.
+    /// </summary>
+    public ListedTest(
+        string filePath,
+        IReadOnlyList<string> descriptionPath,
+        string name)
+    {
+        FilePath = filePath;
+        DescriptionPath = descriptionPath;
+        Name = name;
+    }
+
+    /// <summary>
+    /// Gets the test module's path relative to the Elm project.
+    /// </summary>
+    public string FilePath { get; init; }
+
+    /// <summary>
+    /// Gets the path of nested descriptions containing the test.
+    /// </summary>
+    public IReadOnlyList<string> DescriptionPath { get; init; }
+
+    /// <summary>
+    /// Gets the test name.
+    /// </summary>
+    public string Name { get; init; }
+
+    /// <inheritdoc/>
+    public bool Equals(ListedTest? other) =>
+        ReferenceEquals(this, other) ||
+        (other is not null &&
+        FilePath == other.FilePath &&
+        DescriptionPath.SequenceEqual(other.DescriptionPath, StringComparer.Ordinal) &&
+        Name == other.Name);
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        var hashCode = new HashCode();
+
+        hashCode.Add(FilePath, StringComparer.Ordinal);
+
+        foreach (var description in DescriptionPath)
+            hashCode.Add(description, StringComparer.Ordinal);
+
+        hashCode.Add(Name, StringComparer.Ordinal);
+
+        return hashCode.ToHashCode();
+    }
+}
+
+
 /// <summary>
 /// Contains a styled fragment of rendered test output.
 /// </summary>
@@ -1102,6 +1189,41 @@ public sealed record Completed(
         TimeSpan Duration)
         : ElmTestRun;
 
+    /// <summary>
+    /// Contains tests discovered without running them.
+    /// </summary>
+    public sealed record Listed : ElmTestRun
+    {
+        /// <summary>
+        /// Creates a result containing tests discovered without running them.
+        /// </summary>
+        public Listed(IReadOnlyList<ListedTest> tests)
+        {
+            Tests = tests;
+        }
+
+        /// <summary>
+        /// Gets the discovered tests.
+        /// </summary>
+        public IReadOnlyList<ListedTest> Tests { get; init; }
+
+        /// <inheritdoc/>
+        public bool Equals(Listed? other) =>
+            ReferenceEquals(this, other) ||
+            (other is not null && Tests.SequenceEqual(other.Tests));
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            var hashCode = new HashCode();
+
+            foreach (var test in Tests)
+                hashCode.Add(test);
+
+            return hashCode.ToHashCode();
+        }
+    }
+
     /// <summary>
     /// Represents a test run for a project without Elm test modules.
     /// </summary>