namespace Specs { class Cat { void ItMeows() {}}}

Author: beccasaurus

MiniSpec/PrivateAPI/TestDiscoverer.cs

@@ -21,31 +21,29 @@ internal TestDiscoverer(Assembly assembly, TestSuite testSuite, TestExecutor tes
       _reporter = testReporter;
     }
 
-    internal List<string> TEST_OBJECT_NAME_PATTERNS = new List<string> { "^[a-zA-Z].*Test", "^[a-zA-Z].*Spec", "^Test", "^Spec" };
-    internal List<string> TEST_OBJECT_CHILD_TEST_NAME_PATTERNS = new List<string> { "^[a-zA-Z]" };
+    internal List<string> TEST_OR_TEST_GROUP_NAME_PATTERNS = new List<string> { "^[A-Z].*Test", "^[A-Z].*Spec", "^Test", "^Spec" };
+    internal List<string> TEST_GROUP_CHILD_TEST_NAME_PATTERNS = new List<string> { "^[A-Z].*Test", "^[A-Z].*Spec", "^Test", "^Spec", "^It", "^Should", "^Can" };
 
     internal void FindAndExecutorTests()
     {
       foreach (var type in _assembly.GetTypes())
       {
         var isTestType = false;
-        foreach (var pattern in TEST_OBJECT_NAME_PATTERNS)
-        {
-          var typeMethods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static);
-          foreach (var method in typeMethods)
-          {
-            var methodName = GetTestMethodName(method.Name);
-            var isTestMethod = false;
-            foreach (var testObjectPattern in TEST_OBJECT_NAME_PATTERNS) {
-                if (new Regex(testObjectPattern).IsMatch(methodName)) {
-                    isTestMethod = true;
-                    break;
-                }
-            }
-            if (isTestMethod) {
-                _reporter.BeforeTest(methodName);
-                var result = _executor.ExecuteTestMethod(method);
-            }
+        foreach (var pattern in TEST_OR_TEST_GROUP_NAME_PATTERNS)
+          if (new Regex(pattern).IsMatch(type.Name) || new Regex(pattern).IsMatch(type.FullName)) { isTestType = true; break; }
+
+        var typeMethods = new List<MethodInfo>(type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance));
+        typeMethods.AddRange(type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static));
+
+        foreach (var method in typeMethods) {
+          var methodName = GetTestMethodName(method.Name);
+          var isTestMethod = false;
+          var patternsToTest = isTestType ? TEST_GROUP_CHILD_TEST_NAME_PATTERNS : TEST_OR_TEST_GROUP_NAME_PATTERNS;
+          foreach (var pattern in patternsToTest)
+              if (new Regex(pattern).IsMatch(methodName)) { isTestMethod = true; break; }
+          if (isTestMethod) {
+              _reporter.BeforeTest(methodName);
+              var result = _executor.ExecuteTestMethod(method);
           }
         }
       }

spec/CLI/ListSpecs.Spec.cs

@@ -32,5 +32,52 @@ void UnreleatedFunction2() {}
         new Regex($"^{unexpectedTestName}", RegexOptions.Multiline)
         .IsMatch(project.RunResult.StandardOutput).Should().BeFalse($"Expected this not to be listed as a test name: {unexpectedTestName}");
     }
+
+    // [TestCase(framework, TestName = "")] ~ for different framework versions (skip unsupported with Assert.Ignore())
+    [Test]
+    public void ListInstanceMethodsOfClass() {
+      var project = CreateProject(csharp: 9, framework: Project.TargetFrameworks.Net50, type: Project.OutputTypes.Exe);
+      project.WriteFile("Program.cs", @"
+      return MiniSpec.Tests.Run(args);
+      class RegularClass {
+        void TestOne() {}
+        void TestTwo() {}
+        void notATest() {}
+        void _NotATest() {}
+        void ItDoesSomething() {} // Not a test because 'It' only works in a test group
+      }
+      class DogTest {
+        void ItBarks() {}
+        void ShouldBark() {}
+        void CanBark() {}
+        void UnrelatedDog() {}
+      }
+      namespace Tests {
+        class Cat {
+          void ItMeows() {}
+          void ShouldMeow() {}
+          void CanMeow() {}
+          void UnrelatedCat() {}
+        }
+      }
+      ");
+
+      project.Run("-l");
+
+      System.Console.WriteLine($"OUTPUT: {project.RunResult.StandardOutput}");
+
+      project.RunResult.StandardError.Should().BeEmpty();
+      project.RunResult.OK.Should().BeTrue();
+
+      foreach (var expectedTestName in new[] { "TestOne", "TestTwo", "ItBarks", "ShouldBark", "CanBark", "ItMeows", "ShouldMeow", "CanMeow" })
+        new Regex($"^{expectedTestName}", RegexOptions.Multiline)
+        .IsMatch(project.RunResult.StandardOutput).Should().BeTrue($"Expected listed test name: {expectedTestName}");
+
+      foreach (var unexpectedTestName in new[] { "notATest", "_NotATest", "UnrelatedDog", "UnrelatedCat" })
+        new Regex($"^{unexpectedTestName}", RegexOptions.Multiline)
+        .IsMatch(project.RunResult.StandardOutput).Should().BeFalse($"Expected this not to be listed as a test name: {unexpectedTestName}");
+    }
+
+    // Next: --list --details (details reporter) for Setup/Teardown/Constructor/Dispose/Group
   }
 }