cypress 6.9.1 → 7.2.0

package/types/lodash/index.d.ts

@@ -10,7 +10,6 @@
 //                 Dominique Rau <https://github.com/DomiR>
 //                 William Chelman <https://github.com/WilliamChelman>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
 
 /// <reference path="./common/common.d.ts" />
 /// <reference path="./common/array.d.ts" />

package/types/net-stubbing.ts

@@ -68,19 +68,37 @@ type Method =
     | 'unlink'
     | 'unlock'
     | 'unsubscribe'
-
 export namespace CyHttpMessages {
   export interface BaseMessage {
-    body?: any
+    /**
+     * The body of the HTTP message.
+     * If a JSON Content-Type was used and the body was valid JSON, this will be an object.
+     * If the body was binary content, this will be a buffer.
+     */
+    body: any
+    /**
+     * The headers of the HTTP message.
+     */
     headers: { [key: string]: string }
-    url: string
-    method?: Method
-    httpVersion?: string
   }
 
   export type IncomingResponse = BaseMessage & {
+    /**
+     * The HTTP status code of the response.
+     */
     statusCode: number
+    /**
+     * The HTTP status message.
+     */
     statusMessage: string
+    /**
+     * Kilobytes per second to send 'body'.
+     */
+    throttleKbps?: number
+    /**
+     * Milliseconds to delay before the response is sent.
+     */
+    delay?: number
   }
 
   export type IncomingHttpResponse = IncomingResponse & {
@@ -97,14 +115,30 @@ export namespace CyHttpMessages {
     /**
      * Wait for `delay` milliseconds before sending the response to the client.
      */
-    delay: (delay: number) => IncomingHttpResponse
+    setDelay: (delay: number) => IncomingHttpResponse
     /**
      * Serve the response at `throttleKbps` kilobytes per second.
      */
-    throttle: (throttleKbps: number) => IncomingHttpResponse
+    setThrottle: (throttleKbps: number) => IncomingHttpResponse
   }
 
   export type IncomingRequest = BaseMessage & {
+    /**
+     * Request HTTP method (GET, POST, ...).
+     */
+    method: string
+    /**
+     * Request URL.
+     */
+    url: string
+    /**
+     * The HTTP version used in the request. Read only.
+     */
+    httpVersion: string
+    /**
+     * If provided, the number of milliseconds before an upstream response to this request
+     * will time out and cause an error. By default, `responseTimeout` from config is used.
+     */
     responseTimeout?: number
     /**
      * Set if redirects should be followed when this request is made. By default, requests will
@@ -118,11 +152,17 @@ export namespace CyHttpMessages {
     alias?: string
   }
 
-  export interface IncomingHttpRequest extends IncomingRequest {
+  export interface IncomingHttpRequest extends IncomingRequest, RequestEvents {
     /**
      * Destroy the request and respond with a network error.
      */
     destroy(): void
+    /**
+     * Send the request outgoing, skipping any other request handlers.
+     * If a function is passed, the request will be sent outgoing, and the function will be called
+     * with the response from the upstream server.
+     */
+    continue(interceptor?: HttpResponseInterceptor): void
     /**
      * Control the response to this request.
      * If a function is passed, the request will be sent outgoing, and the function will be called
@@ -145,6 +185,14 @@ export namespace CyHttpMessages {
      */
     redirect(location: string, statusCode?: number): void
   }
+
+  export interface ResponseComplete {
+    finalResBody?: BaseMessage['body']
+  }
+
+  export interface NetworkError {
+    error: any
+  }
 }
 
 export interface DictMatcher<T> {
@@ -175,14 +223,49 @@ export type HttpResponseInterceptor = (res: CyHttpMessages.IncomingHttpResponse)
  */
 export type NumberMatcher = number | number[]
 
+/**
+ * Metadata for a subscription for an interception event.
+ */
+export interface Subscription {
+  /**
+   * If not defined, this is a default subscription.
+   */
+  id?: string
+  routeId: string
+  eventName: string
+  await: boolean
+  skip?: boolean
+}
+
+interface RequestEvents {
+  /**
+   * Emitted before `response` and before any `req.continue` handlers.
+   * Modifications to `res` will be applied to the incoming response.
+   * If a promise is returned from `cb`, it will be awaited before processing other event handlers.
+   */
+  on(eventName: 'before:response', cb: HttpResponseInterceptor): this
+  /**
+   * Emitted after `before:response` and after any `req.continue` handlers - before the response is sent to the browser.
+   * Modifications to `res` will be applied to the incoming response.
+   * If a promise is returned from `cb`, it will be awaited before processing other event handlers.
+   */
+  on(eventName: 'response', cb: HttpResponseInterceptor): this
+  /**
+   * Emitted once the response to a request has finished sending to the browser.
+   * Modifications to `res` have no impact.
+   * If a promise is returned from `cb`, it will be awaited before processing other event handlers.
+   */
+  on(eventName: 'after:response', cb: (res: CyHttpMessages.IncomingResponse) => void | Promise<void>): this
+}
+
 /**
  * Request/response cycle.
  */
 export interface Interception {
   id: string
-  routeHandlerId: string
+  routeId: string
   /* @internal */
-  log: any
+  log?: any
   request: CyHttpMessages.IncomingRequest
   /**
    * Was `cy.wait()` used to wait on this request?
@@ -190,8 +273,6 @@ export interface Interception {
    */
   requestWaited: boolean
   response?: CyHttpMessages.IncomingResponse
-  /* @internal */
-  responseHandler?: HttpResponseInterceptor
   /**
    * The error that occurred during this request.
    */
@@ -203,6 +284,11 @@ export interface Interception {
   responseWaited: boolean
   /* @internal */
   state: InterceptionState
+  /* @internal */
+  subscriptions: Array<{
+    subscription: Subscription
+    handler: (data: any) => Promise<void> | void
+  }>
 }
 
 export type InterceptionState =
@@ -250,16 +336,17 @@ export interface RouteMatcherOptionsGeneric<S> {
    * 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 '*'
    */
   method?: S
+  /**
+   * If `true`, this handler will be called before any non-`middleware` handlers, in the order it was defined.
+   * Can only be used with a dynamic request handler.
+   * @default false
+   */
+  middleware?: boolean
   /**
    * Match on request path after the hostname, including query params.
    */
@@ -292,7 +379,7 @@ export type RouteHandler = string | StaticResponse | RouteHandlerController | ob
 /**
  * Describes a response that will be sent back to the browser to fulfill the request.
  */
-export type StaticResponse = GenericStaticResponse<string, string | object> & {
+export type StaticResponse = GenericStaticResponse<string, string | object | boolean | null> & {
   /**
    * Milliseconds to delay before the response is sent.
    * @deprecated Use `delay` instead of `delayMs`.
@@ -326,13 +413,13 @@ export interface GenericStaticResponse<Fixture, Body> {
    */
   forceNetworkError?: boolean
   /**
-   * Kilobits per second to send 'body'.
+   * Kilobytes per second to send 'body'.
    */
   throttleKbps?: number
   /**
    * Milliseconds to delay before the response is sent.
    */
-   delay?: number
+  delay?: number
 }
 
 /**
@@ -372,6 +459,8 @@ interface WaitOptions {
 
 declare global {
   namespace Cypress {
+    // TODO: Why is Subject unused?
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     interface Chainable<Subject = any> {
       /**
        * Use `cy.intercept()` to stub and intercept HTTP requests and responses.
@@ -385,7 +474,7 @@ declare global {
        *    })
        * @example
        *    cy.intercept('https://localhost:7777/some-response', (req) => {
-       *      req.reply(res => {
+       *      req.continue(res => {
        *        res.body = 'some new body'
        *      })
        *    })
@@ -400,13 +489,16 @@ declare global {
        */
       intercept(method: Method, url: RouteMatcher, response?: RouteHandler): Chainable<null>
       /**
-       * @deprecated Use `cy.intercept()` instead.
-       */
-      route2(url: RouteMatcher, response?: RouteHandler): Chainable<null>
-      /**
-       * @deprecated Use `cy.intercept()` instead.
+       * Use `cy.intercept()` to stub and intercept HTTP requests and responses.
+       *
+       * @see https://on.cypress.io/intercept
+       *
+       * @example
+       *    cy.intercept('/fruits', { middleware: true }, (req) => { ... })
+       *
+       * @param mergeRouteMatcher Additional route matcher options to merge with `url`. Typically used for middleware.
        */
-      route2(method: Method, url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      intercept(url: string, mergeRouteMatcher: Omit<RouteMatcherOptions, 'url'>, response: RouteHandler): Chainable<null>
       /**
        * Wait for a specific request to complete.
        *