Fix --testNamePattern matching against it.concurrent within describe

CHANGELOG.md

@@ -41,6 +41,7 @@
 - `[jest-snapshot]` [**BREAKING**] Distinguish empty string from internal snapshot not written ([#8898](https://github.com/facebook/jest/pull/8898))
 - `[jest-snapshot]` [**BREAKING**] Remove `report` method and throw matcher errors ([#9049](https://github.com/facebook/jest/pull/9049))
 - `[jest-transform]` Properly cache transformed files across tests ([#8890](https://github.com/facebook/jest/pull/8890))
+- `[jest-jasmine2]` Fix `--testNamePattern` matching with `concurrent` tests ([#9090](https://github.com/facebook/jest/pull/9090))
 
 ### Chore & Maintenance
 

e2e/__tests__/jasmineAsync.test.ts

@@ -115,6 +115,19 @@ describe('async jasmine', () => {
     expect(json.testResults[0].message).toMatch(/concurrent test fails/);
   });
 
+  it('works with concurrent within a describe block when invoked with testNamePattern', () => {
+    const {json} = runWithJson('jasmine-async', [
+      '--testNamePattern',
+      'one concurrent test fails',
+      'concurrentWithinDescribe.test.js',
+    ]);
+    expect(json.numTotalTests).toBe(1);
+    expect(json.numPassedTests).toBe(0);
+    expect(json.numFailedTests).toBe(1);
+    expect(json.numPendingTests).toBe(0);
+    expect(json.testResults[0].message).toMatch(/concurrent test fails/);
+  });
+
   it("doesn't execute more than 5 tests simultaneously", () => {
     const {json} = runWithJson('jasmine-async', ['concurrent-many.test.js']);
     expect(json.numTotalTests).toBe(10);

e2e/jasmine-async/__tests__/concurrentWithinDescribe.test.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+describe('one', () => {
+  it.concurrent('concurrent test fails', () => Promise.reject());
+});

packages/jest-jasmine2/src/jasmine/Env.ts

@@ -55,7 +55,7 @@ export default function(j$: Jasmine) {
     fail: (error: Error | AssertionErrorWithStack) => void;
     pending: (message: string) => void;
     afterAll: (afterAllFunction: QueueableFn['fn'], timeout?: number) => void;
-    fit: (description: string, fn: QueueableFn['fn'], timeout?: number) => void;
+    fit: (description: string, fn: QueueableFn['fn'], timeout?: number) => Spec;
     throwingExpectationFailures: () => boolean;
     randomizeTests: (value: unknown) => void;
     randomTests: () => boolean;
@@ -79,7 +79,7 @@ export default function(j$: Jasmine) {
     addReporter: (reporterToAdd: Reporter) => void;
     it: (description: string, fn: QueueableFn['fn'], timeout?: number) => Spec;
     xdescribe: (description: string, specDefinitions: Function) => Suite;
-    xit: (description: string, fn: QueueableFn['fn'], timeout?: number) => any;
+    xit: (description: string, fn: QueueableFn['fn'], timeout?: number) => Spec;
     beforeAll: (beforeAllFunction: QueueableFn['fn'], timeout?: number) => void;
     todo: () => Spec;
     provideFallbackReporter: (reporterToAdd: Reporter) => void;

packages/jest-jasmine2/src/jasmineAsyncInstall.ts

@@ -17,6 +17,7 @@ import throat from 'throat';
 import isError from './isError';
 import {Jasmine} from './types';
 import Spec from './jasmine/Spec';
+import {QueueableFn} from './queueRunner';
 
 interface DoneFn {
   (): void;
@@ -141,34 +142,37 @@ function promisifyIt(
 }
 
 function makeConcurrent(
-  originalFn: Function,
+  originalFn: (
+    description: string,
+    fn: QueueableFn['fn'],
+    timeout?: number,
+  ) => Spec,
   env: Jasmine['currentEnv_'],
   mutex: ReturnType<typeof throat>,
 ): Global.ItConcurrentBase {
   return function(specName, fn, timeout) {
-    if (
-      env != null &&
-      !env.specFilter({getFullName: () => specName || ''} as Spec)
-    ) {
-      return originalFn.call(env, specName, () => Promise.resolve(), timeout);
+    let promise: Promise<unknown> = Promise.resolve();
+
+    const spec = originalFn.call(env, specName, () => promise, timeout);
+    if (env != null && !env.specFilter(spec)) {
+      return spec;
     }
 
-    let promise: Promise<unknown>;
     try {
       promise = mutex(() => {
         const promise = fn();
         if (isPromise(promise)) {
           return promise;
         }
         throw new Error(
-          `Jest: concurrent test "${specName}" must return a Promise.`,
+          `Jest: concurrent test "${spec.getFullName()}" must return a Promise.`,
         );
       });
     } catch (error) {
-      return originalFn.call(env, specName, () => Promise.reject(error));
+      promise = Promise.reject(error);
     }
 
-    return originalFn.call(env, specName, () => promise, timeout);
+    return spec;
   };
 }