Automatically discover children for test files that weren't expanded (#3336)

### Motivation

I noticed that executing entire test directories through the explorer wasn't working. This is due to #3335 and the aspect that we were not automatically discovering the children of test files if they were never expanded.

That meant that, we had no knowledge of their children existing, but when running the tests we are reporting results for those children we know nothing about.

We need to automatically resolve children for test files that haven't been expanded otherwise the items we need to update don't exist.

### Implementation

It's just a matter of invoking our resolve handler if there are no children in the test file item.

### Automated Tests

Added a test.

Author: vinistock

vscode/src/test/suite/testController.test.ts

@@ -872,6 +872,89 @@ suite("TestController", () => {
     });
   });
 
+  test("finding an item inside a test file that was never expanded automatically discovers children", async () => {
+    const commonStub = sinon.stub(common, "featureEnabled").returns(true);
+    const controller = new TestController(
+      context,
+      FAKE_TELEMETRY,
+      () => undefined,
+      () => Promise.resolve(workspace),
+    );
+    commonStub.restore();
+
+    const workspacesStub = sinon
+      .stub(vscode.workspace, "workspaceFolders")
+      .get(() => [workspaceFolder]);
+
+    const relativePathStub = sinon
+      .stub(vscode.workspace, "asRelativePath")
+      .callsFake((uri) =>
+        path.relative(workspacePath, (uri as vscode.Uri).fsPath),
+      );
+
+    await controller.testController.resolveHandler!(undefined);
+    const collection = controller.testController.items;
+    const testDirUri = vscode.Uri.joinPath(workspaceUri, "test");
+    const testDir = collection.get(testDirUri.toString());
+    assert.ok(testDir);
+
+    const serverTestUri = vscode.Uri.joinPath(
+      workspaceUri,
+      "test",
+      "server_test.rb",
+    );
+    const serverTest = testDir.children.get(serverTestUri.toString());
+    assert.ok(serverTest);
+
+    const fakeClient = {
+      discoverTests: sinon.stub().resolves([
+        {
+          id: "ServerTest",
+          uri: serverTestUri.toString(),
+          label: "ServerTest",
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 12, character: 10 },
+          },
+          tags: ["minitest"],
+          children: [
+            {
+              id: "ServerTest::NestedTest",
+              uri: serverTestUri.toString(),
+              label: "NestedTest",
+              range: {
+                start: { line: 2, character: 0 },
+                end: { line: 10, character: 10 },
+              },
+              tags: ["minitest"],
+              children: [
+                {
+                  id: "ServerTest::NestedTest#test_something",
+                  uri: serverTestUri.toString(),
+                  label: "test_something",
+                  range: {
+                    start: { line: 2, character: 0 },
+                    end: { line: 10, character: 10 },
+                  },
+                  tags: ["minitest"],
+                  children: [],
+                },
+              ],
+            },
+          ],
+        },
+      ]),
+      waitForIndexing: sinon.stub().resolves(),
+    };
+    workspace.lspClient = fakeClient as any;
+
+    await controller.findTestItem("ServerTest", serverTestUri);
+    assert.strictEqual(fakeClient.discoverTests.callCount, 1);
+
+    workspacesStub.restore();
+    relativePathStub.restore();
+  });
+
   test("running a test", async () => {
     await withController(async (controller) => {
       const uri = vscode.Uri.joinPath(workspaceUri, "test", "server_test.rb");

vscode/src/testController.ts

@@ -387,6 +387,12 @@ export class TestController {
       return testFileItem;
     }
 
+    // If we're trying to find a test item inside a file that has never been expanded, then we never discovered its
+    // children and need to do so before trying to access them
+    if (testFileItem.children.size === 0) {
+      await this.resolveHandler(testFileItem);
+    }
+
     // If we find an exact match for this ID, then return it right away
     const groupOrItem = testFileItem.children.get(id);
     if (groupOrItem) {