fix(net-stubbing): match cy.intercept(url) globs against url+path (#1…

…4241)

Co-authored-by: Jennifer Shehane <jennifer@cypress.io>

packages/driver/cypress/integration/commands/net_stubbing_spec.ts

@@ -60,6 +60,7 @@ describe('network stubbing', { retries: 2 }, function () {
             type: 'glob',
             value: url,
           },
+          matchUrlAgainstPath: true,
         },
         staticResponse: {
           body: 'bar',
@@ -68,7 +69,7 @@ describe('network stubbing', { retries: 2 }, function () {
       }
 
       const expectedRoute = {
-        options: { url },
+        options: { url, matchUrlAgainstPath: true },
         handler,
       }
 
@@ -87,12 +88,13 @@ describe('network stubbing', { retries: 2 }, function () {
             type: 'glob',
             value: url,
           },
+          matchUrlAgainstPath: true,
         },
         hasInterceptor: true,
       }
 
       const expectedRoute = {
-        options: { url },
+        options: { url, matchUrlAgainstPath: true },
         handler,
       }
 
@@ -124,7 +126,6 @@ describe('network stubbing', { retries: 2 }, function () {
           quuz: /(.*)quux/gi,
         },
         url: 'http://foo.invalid',
-        webSocket: false,
       }
 
       const expectedEvent = {
@@ -181,7 +182,6 @@ describe('network stubbing', { retries: 2 }, function () {
             type: 'glob',
             value: options.url,
           },
-          webSocket: options.webSocket,
         },
         hasInterceptor: true,
       }
@@ -406,6 +406,32 @@ describe('network stubbing', { retries: 2 }, function () {
             },
           })
         })
+
+        it('must set `url` with `matchUrlAgainstPath`', function (done) {
+          cy.on('fail', function (err) {
+            expect(err.message).to.include('`matchUrlAgainstPath` requires a `url` to be specified.')
+
+            done()
+          })
+
+          cy.intercept({
+            matchUrlAgainstPath: true,
+          })
+        })
+
+        it('must not set `path` with `matchUrlAgainstPath`', function (done) {
+          cy.on('fail', function (err) {
+            expect(err.message).to.include('`matchUrlAgainstPath` and `path` cannot both be set.')
+
+            done()
+          })
+
+          cy.intercept({
+            matchUrlAgainstPath: true,
+            path: '*',
+            url: '*',
+          })
+        })
       })
 
       context('with invalid handler', function () {
@@ -1121,6 +1147,29 @@ describe('network stubbing', { retries: 2 }, function () {
         })
         .wait('@foo')
       })
+
+      // @see https://github.com/cypress-io/cypress/issues/9379
+      context('falls back to matching by path if plain string is passed', function () {
+        it('matches globs against path', function (done) {
+          cy.intercept('/foo/*', (req) => {
+            expect(req.url).to.include('/foo/1')
+            done()
+          })
+          .then(() => {
+            $.ajax({ url: '/foo/1', cache: true })
+          })
+        })
+
+        it('matches nested globs against path', function (done) {
+          cy.intercept('/foo/*/bar', (req) => {
+            expect(req.url).to.match(/\/foo\/1\/bar$/)
+            done()
+          })
+          .then(() => {
+            $.get({ url: '/foo/1/bar', cache: true })
+          })
+        })
+      })
     })
 
     context('with StaticResponse shorthand', function () {

packages/driver/src/cy/net-stubbing/add-command.ts

@@ -67,7 +67,7 @@ function annotateMatcherOptionsTypes (options: RouteMatcherOptions) {
     }
   })
 
-  const noAnnotationRequiredFields = ['https', 'port', 'webSocket']
+  const noAnnotationRequiredFields: (keyof RouteMatcherOptions)[] = ['https', 'port', 'matchUrlAgainstPath']
 
   _.extend(ret, _.pick(options, noAnnotationRequiredFields))
 
@@ -113,8 +113,12 @@ function validateRouteMatcherOptions (routeMatcher: RouteMatcherOptions): { isVa
     }
   }
 
-  if (_.has(routeMatcher, 'https') && !_.isBoolean(routeMatcher.https)) {
-    return err('`https` must be a boolean.')
+  const booleanProps = ['https', 'matchUrlAgainstPath']
+
+  for (const prop of booleanProps) {
+    if (_.has(routeMatcher, prop) && !_.isBoolean(routeMatcher[prop])) {
+      return err(`\`${prop}\` must be a boolean.`)
+    }
   }
 
   if (_.has(routeMatcher, 'port') && !isNumberMatcher(routeMatcher.port)) {
@@ -133,6 +137,16 @@ function validateRouteMatcherOptions (routeMatcher: RouteMatcherOptions): { isVa
     }
   }
 
+  if (routeMatcher.matchUrlAgainstPath) {
+    if (!routeMatcher.url) {
+      return err('`matchUrlAgainstPath` requires a `url` to be specified.')
+    }
+
+    if (routeMatcher.path) {
+      return err('`matchUrlAgainstPath` and `path` cannot both be set.')
+    }
+  }
+
   return { isValid: true }
 }
 
@@ -280,6 +294,7 @@ export function addCommand (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy,
         handler = arg2
 
         return {
+          matchUrlAgainstPath: true,
           method: matcher,
           url,
         }
@@ -288,6 +303,7 @@ export function addCommand (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy,
       if (isStringMatcher(matcher)) {
         // url, handler
         return {
+          matchUrlAgainstPath: true,
           url: matcher,
         }
       }

packages/net-stubbing/lib/external-types.ts

@@ -230,13 +230,9 @@ export interface RouteMap { [key: string]: Route }
  */
 export type RouteMatcher = StringMatcher | RouteMatcherOptions
 
-export interface RouteMatcherCompatOptions {
-  response?: string | object
-}
-
 export type RouteMatcherOptions = RouteMatcherOptionsGeneric<StringMatcher>
 
-export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions {
+export interface RouteMatcherOptionsGeneric<S> {
   /**
    * Match against the username and password used in HTTP Basic authentication.
    */
@@ -254,6 +250,11 @@ export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions
    * If 'false', only HTTP requests will be matched.
    */
   https?: boolean
+  /**
+   * If `true`, will match the supplied `url` against incoming `path`s.
+   * Requires a `url` argument. Cannot be used with a `path` argument.
+   */
+  matchUrlAgainstPath?: boolean
   /**
    * Match against the request's HTTP method.
    * @default '*'

packages/net-stubbing/lib/server/driver-events.ts

@@ -62,7 +62,7 @@ export function _restoreMatcherOptionsTypes (options: AnnotatedRouteMatcherOptio
     _.set(ret, field, value)
   })
 
-  const noAnnotationRequiredFields = ['https', 'port', 'webSocket']
+  const noAnnotationRequiredFields: (keyof AnnotatedRouteMatcherOptions)[] = ['https', 'port', 'matchUrlAgainstPath']
 
   _.extend(ret, _.pick(options, noAnnotationRequiredFields))
 

packages/net-stubbing/lib/server/route-matching.ts

@@ -23,12 +23,28 @@ export function _doesRouteMatch (routeMatcher: RouteMatcherOptions, req: Cypress
     let matcher = _.get(routeMatcher, field)
     let value = _.get(matchable, field, '')
 
+    // for convenience, attempt to match `url` against `path`?
+    const shouldTryMatchingPath = field === 'url' && routeMatcher.matchUrlAgainstPath
+
+    const stringMatch = (value: string, matcher: string) => {
+      return (
+        value === matcher ||
+        minimatch(value, matcher, { matchBase: true }) ||
+        (field === 'url' && (
+          // substring match
+          value.includes(matcher) ||
+          // be nice and match paths that are missing leading slashes
+          (value[0] === '/' && matcher[0] !== '/' && stringMatch(value, `/${matcher}`))
+        ))
+      )
+    }
+
     if (typeof value !== 'string') {
       value = String(value)
     }
 
     if (matcher.test) {
-      if (!matcher.test(value)) {
+      if (!matcher.test(value) && (!shouldTryMatchingPath || !matcher.test(matchable.path))) {
         return false
       }
 
@@ -42,13 +58,7 @@ export function _doesRouteMatch (routeMatcher: RouteMatcherOptions, req: Cypress
       matcher = matcher.toLowerCase()
     }
 
-    if (field === 'url') {
-      if (value.includes(matcher)) {
-        continue
-      }
-    }
-
-    if (!minimatch(value, matcher, { matchBase: true })) {
+    if (!stringMatch(value, matcher) && (!shouldTryMatchingPath || !stringMatch(matchable.path, matcher))) {
       return false
     }
   }