cypress 4.12.1 → 5.3.0

package/types/net-stubbing.ts

@@ -0,0 +1,257 @@
+/**
+ * HTTP request/response types.
+ */
+export namespace CyHttpMessages {
+  interface BaseMessage {
+    // as much stuff from `incomingmessage` as makes sense to serialize and send
+    body?: any
+    headers: { [key: string]: string }
+    url: string
+    method?: string
+    httpVersion?: string
+  }
+
+  export type IncomingResponse = BaseMessage & {
+    statusCode: number
+    statusMessage: string
+  }
+
+  export type IncomingHttpResponse = IncomingResponse & {
+    /**
+     * Continue the HTTP response, merging the supplied values with the real response.
+     */
+    send(status: number, body?: string | number | object, headers?: { [key: string]: string }): void
+    send(body: string | object, headers?: { [key: string]: string }): void
+    send(staticResponse: StaticResponse): void
+    /**
+     * Continue the HTTP response to the browser, including any modifications made to `res`.
+     */
+    send(): void
+    /**
+     * Wait for `delayMs` milliseconds before sending the response to the client.
+     */
+    delay: (delayMs: number) => IncomingHttpResponse
+    /**
+     * Serve the response at `throttleKbps` kilobytes per second.
+     */
+    throttle: (throttleKbps: number) => IncomingHttpResponse
+  }
+
+  export type IncomingRequest = BaseMessage & {
+    responseTimeout?: number
+    /**
+     * Set if redirects should be followed when this request is made. By default, requests will
+     * not follow redirects before yielding the response (the 3xx redirect is yielded)
+     */
+    followRedirect?: boolean
+  }
+
+  export interface IncomingHttpRequest extends IncomingRequest {
+    destroy(): void
+    reply(interceptor?: StaticResponse | HttpResponseInterceptor): void
+    reply(body: string | object, headers?: { [key: string]: string }): void
+    reply(status: number, body?: string | object, headers?: { [key: string]: string }): void
+    redirect(location: string, statusCode: number): void
+  }
+}
+
+export interface DictMatcher<T> {
+  [key: string]: T
+}
+
+/**
+ * Matches a string using glob (`*`) matching.
+ */
+export type GlobPattern = string
+
+export type HttpRequestInterceptor = (req: CyHttpMessages.IncomingHttpRequest) => void | Promise<void>
+
+export type HttpResponseInterceptor = (res: CyHttpMessages.IncomingHttpResponse, send?: () => void) => void | Promise<void>
+
+/**
+ * Matches a single number or any of an array of acceptable numbers.
+ */
+export type NumberMatcher = number | number[]
+
+/**
+ * Request/response cycle.
+ */
+export interface Request {
+  id: string
+  /* @internal */
+  log: any
+  request: CyHttpMessages.IncomingRequest
+  /**
+   * Was `cy.wait()` used to wait on this request?
+   * @internal
+   */
+  requestWaited: boolean
+  response?: CyHttpMessages.IncomingResponse
+  /* @internal */
+  responseHandler?: HttpResponseInterceptor
+  /**
+   * Was `cy.wait()` used to wait on the response to this request?
+   * @internal
+   */
+  responseWaited: boolean
+  /* @internal */
+  state: RequestState
+}
+
+export type RequestState =
+  'Received' |
+  'Intercepted' |
+  'ResponseReceived' |
+  'ResponseIntercepted' |
+  'Complete' |
+  'Errored'
+
+export interface Route {
+  alias?: string
+  log: any
+  options: RouteMatcherOptions
+  handler: RouteHandler
+  hitCount: number
+  requests: { [key: string]: Request }
+}
+
+export interface RouteMap { [key: string]: Route }
+
+/**
+ * A `RouteMatcher` describes a filter for HTTP requests.
+ */
+export type RouteMatcher = StringMatcher | RouteMatcherOptions
+
+export interface RouteMatcherCompatOptions {
+  response?: string | object
+}
+
+export type RouteMatcherOptions = RouteMatcherOptionsGeneric<StringMatcher>
+
+export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions {
+  /**
+   * Match HTTP basic authentication.
+   */
+  auth?: { username: S, password: S }
+  /**
+   * Match client request headers.
+   */
+  headers?: DictMatcher<S>
+  /**
+   * Match based on requested hostname.
+   */
+  hostname?: S
+  /**
+   * Match requests served via HTTPS only.
+   */
+  https?: boolean
+  /**
+   * @default 'GET'
+   */
+  method?: S
+  /**
+   * Match on request path after the hostname, including query params.
+   */
+  path?: S
+  /**
+   * Matches like `path`, but without query params.
+   */
+  pathname?: S
+  /**
+   * Match based on requested port.
+   */
+  port?: NumberMatcher
+  /**
+   * Match on parsed querystring parameters.
+   */
+  query?: DictMatcher<S>
+  /**
+   * Match based on full request URL.
+   */
+  url?: S
+}
+
+export type RouteHandlerController = HttpRequestInterceptor
+
+export type RouteHandler = string | StaticResponse | RouteHandlerController | object
+
+/**
+ * Describes a response that will be sent back to the browser to fulfill the request.
+ */
+export type StaticResponse = GenericStaticResponse<string, string | object> & {
+  /**
+  * If set, `delayMs` will pass before the response is sent.
+  */
+ delayMs?: number
+}
+
+export interface GenericStaticResponse<Fixture, Body> {
+  /**
+   * If set, serve a fixture as the response body.
+   */
+  fixture?: Fixture
+  /**
+   * If set, serve a static string/JSON object as the response body.
+   */
+  body?: Body
+  /**
+   * @default {}
+   */
+  headers?: { [key: string]: string }
+  /**
+   * @default 200
+   */
+  statusCode?: number
+  /**
+   * If `forceNetworkError` is truthy, Cypress will destroy the connection to the browser and send no response. Useful for simulating a server that is not reachable. Must not be set in combination with other options.
+   */
+  forceNetworkError?: boolean
+  /**
+   * If set, the `body` will be sent at `throttleKbps` kbps.
+   */
+  throttleKbps?: number
+}
+
+/**
+ * Either a `GlobPattern` string or a `RegExp`.
+ */
+export type StringMatcher = GlobPattern | RegExp
+
+declare global {
+  namespace Cypress {
+    interface Chainable<Subject = any> {
+      /**
+       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       *
+       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
+       * configuration option to `true`.
+       *
+       * @see https://on.cypress.io/route2
+       * @example
+       *    cy.route2('https://localhost:7777/users', [{id: 1, name: 'Pat'}])
+       * @example
+       *    cy.route2('https://localhost:7777/protected-endpoint', (req) => {
+       *      req.headers['authorization'] = 'basic fooabc123'
+       *    })
+       * @example
+       *    cy.route2('https://localhost:7777/some-response', (req) => {
+       *      req.reply(res => {
+       *        res.body = 'some new body'
+       *      })
+       *    })
+       */
+      route2(url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      /**
+       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       *
+       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
+       * configuration option to `true`.
+       *
+       * @see https://on.cypress.io/route2
+       * @example
+       *    cy.route2('GET', 'http://foo.com/fruits', ['apple', 'banana', 'cherry'])
+       */
+      route2(method: string, url: RouteMatcher, response?: RouteHandler): Chainable<null>
+    }
+  }
+}

package/types/blob-util/index.d.ts

@@ -1,97 +0,0 @@
-// Type definitions for blob-util 1.3
-// Project: https://github.com/nolanlawson/blob-util#readme
-// Definitions by: Max Battcher <https://github.com/WorldMaker>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
-
-/**
- * Shim for new Blob() to support older browsers that use the deprecated BlobBuilder API.
- *
- * @param parts content of the Blob
- * @param options usually just `{ type: mimeType }`
- */
-export function createBlob(parts: any[], options?: { type: string }): Blob;
-
-/**
- * Shim for URL.createObjectURL() to support browsers that only have the prefixed webkitURL (e.g. Android <4.4).
- */
-export function createObjectURL(blob: Blob): string;
-
-/**
- * Shim for URL.revokeObjectURL() to support browsers that only have the prefixed webkitURL (e.g. Android <4.4).
- */
-export function revokeObjectURL(url: string): void;
-
-/**
- * Convert a Blob to a binary string.
- */
-export function blobToBinaryString(blob: Blob): Promise<string>;
-
-/**
- * Convert a binary string to a Blob.
- * @param type the content type
- */
-export function binaryStringToBlob(binary: string, type?: string): Promise<Blob>;
-
-/**
- * Convert a Blob to a base-64 string.
- */
-export function blobToBase64String(blob: Blob): Promise<string>;
-
-/**
- * Convert a base-64 string to a Blob.
- * @param type the content type
- */
-export function base64StringToBlob(base64: string, type?: string): Promise<Blob>;
-
-/**
- * Convert a data URL string (e.g. `'data:image/png;base64,iVBORw0KG...'`) to a Blob.
- */
-export function dataURLToBlob(dataURL: string): Promise<Blob>;
-
-/**
- * Convert a Blob to a data URL string (e.g. `'data:image/png;base64,iVBORw0KG...'`).
- */
-export function blobToDataURL(blob: Blob): Promise<string>;
-
-/**
- * Convert an image's src URL to a data URL by loading the image and painting it to a canvas.
- *
- * Note: this will coerce the image to the desired content type, and it will only paint the first frame of an animated GIF.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param crossOrigin for CORS-enabled images, set this to 'Anonymous' to avoid "tainted canvas" errors
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function imgSrcToDataURL(src: string, type?: string, crossOrigin?: string, quality?: number): Promise<string>;
-
-/**
- * Convert a canvas to a Blob.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function canvasToBlob(canvas: HTMLCanvasElement, type?: string, quality?: number): Promise<Blob>;
-
-/**
- * Convert an image's src URL to a Blob by loading the image and painting it to a canvas.
- *
- * Note: this will coerce the image to the desired content type, and it will only paint the first frame of an animated GIF.
- *
- * @param type the content type (optional, defaults to 'image/png')
- * @param crossOrigin for CORS-enabled images, set this to 'Anonymous' to avoid "tainted canvas" errors
- * @param quality a number between 0 and 1 indicating image quality if the requested type is 'image/jpeg' or 'image/webp'
- */
-export function imgSrcToBlob(src: string, type?: string, crossOrigin?: string, quality?: number): Promise<Blob>;
-
-/**
- * Convert an ArrayBuffer to a Blob.
- *
- * @param type the content type
- */
-export function arrayBufferToBlob(arrayBuff: ArrayBuffer, type?: string): Promise<Blob>;
-
-/**
- * Convert a Blob to an ArrayBuffer.
- */
-export function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;