@azure/core-lro 3.0.0-beta.1 → 3.0.0

package/test/matrix.ts

@@ -1,46 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-/**
- * Takes a jagged 2D array and a function and runs the function with every
- * possible combination of elements of each of the arrays
- *
- * For strong type-checking, it is important that the `matrix` have a strong
- * type, such as a `const` literal.
- *
- * @param values - jagged 2D array specifying the arguments and their possible
- *                 values
- * @param handler - the function to run with the different argument combinations
- *
- * @example
- * ```typescript
- * matrix([
- *     [true, false],
- *     [1, 2, 3]
- *   ] as const,
- *   (useLabels: boolean, attempts: number) => {
- *     // This body will run six times with the following parameters:
- *     // - true, 1
- *     // - true, 2
- *     // - true, 3
- *     // - false, 1
- *     // - false, 2
- *     // - false, 3
- *   });
- * ```
- */
-export function matrix<T extends ReadonlyArray<readonly unknown[]>>(
-  values: T,
-  handler: (
-    ...args: { [idx in keyof T]: T[idx] extends ReadonlyArray<infer U> ? U : never }
-  ) => Promise<void>,
-): void {
-  // Classic recursive approach
-  if (values.length === 0) {
-    (handler as () => Promise<void>)();
-  } else {
-    for (const v of values[0]) {
-      matrix(values.slice(1), (...args) => (handler as any)(v, ...args));
-    }
-  }
-}

package/test/utils/coreRestPipelineLro.ts

@@ -1,25 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import { LongRunningOperation, OperationResponse } from "../../src/index.js";
-import { AbortSignalLike } from "@azure/abort-controller";
-import { PipelineRequest } from "@azure/core-rest-pipeline";
-
-type SendOperationFn<T> = (request: PipelineRequest) => Promise<OperationResponse<T>>;
-
-export function createCoreRestPipelineLro<T>(inputs: {
-  sendOperationFn: SendOperationFn<T>;
-  request: PipelineRequest;
-}): LongRunningOperation<T> {
-  const { request, sendOperationFn } = inputs;
-  return {
-    sendInitialRequest: () => sendOperationFn(request),
-    sendPollRequest: (url: string, options?: { abortSignal?: AbortSignalLike }) =>
-      sendOperationFn({
-        ...request,
-        method: "GET",
-        url,
-        abortSignal: options?.abortSignal,
-      }),
-  };
-}

package/test/utils/router.ts

@@ -1,231 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import {
-  HttpClient,
-  HttpMethods,
-  PipelineRequest,
-  PipelineResponse,
-  RestError,
-  createHttpHeaders,
-} from "@azure/core-rest-pipeline";
-import {
-  ImplementationName,
-  LroResponseSpec,
-  Result,
-  RouteProcessor,
-  State,
-  createProcessor,
-  generate,
-} from "./utils.js";
-import { PollerLike, createHttpPoller } from "../../src/index.js";
-import {
-  OperationResponse,
-  RawResponse,
-  ResourceLocationConfig,
-  ResponseBody,
-} from "../../src/http/models.js";
-import { AbortError } from "@azure/abort-controller";
-import { createCoreRestPipelineLro } from "./coreRestPipelineLro.js";
-import { getYieldedValue } from "../getYieldedValue.js";
-
-/**
- * Dummy value for the path of the initial request
- */
-const initialPath = "path";
-
-/**
- * This helper creates an array of route processors where each processor is represented
- * as a generator. This generator representation is needed to handle a sequence of GET
- * requests to the same route. In particular, the first GET request may get
- * a response indicating that the LRO is still in progress but a subsequent
- * GET request may get a response indicating the LRO is in a terminal state.
- */
-export function toLroProcessors(responses: LroResponseSpec[]): RouteProcessor[] {
-  const routeCountMap = new Map<
-    string,
-    {
-      method: HttpMethods;
-      path: string;
-      responseProcessors: ((req: PipelineRequest) => PipelineResponse)[];
-    }
-  >();
-  for (const response of responses) {
-    const { method, path = initialPath, status, body, headers } = response;
-    const key = createRouteKey({ method, path });
-    const routeProcessor = routeCountMap.get(key);
-    if (routeProcessor !== undefined) {
-      routeProcessor.responseProcessors.push(createProcessor({ status, body, headers }));
-    } else {
-      routeCountMap.set(key, {
-        method,
-        path,
-        responseProcessors: [createProcessor({ status, body, headers })],
-      });
-    }
-  }
-  return [...routeCountMap.values()].map(({ responseProcessors, ...rest }) => ({
-    process: generate(...responseProcessors),
-    ...rest,
-  }));
-}
-
-function createRouteKey({ method, path }: { path: string; method: string }): string {
-  return method + ":" + path;
-}
-export function createClient(inputs: {
-  routes: RouteProcessor[];
-  throwOnNon2xxResponse?: boolean;
-}): HttpClient {
-  const { routes, throwOnNon2xxResponse = true } = inputs;
-  const routesTable = new Map(routes.map((route) => [createRouteKey(route), route]));
-  return {
-    async sendRequest(request: PipelineRequest): Promise<PipelineResponse> {
-      if (request.abortSignal?.aborted) {
-        throw new AbortError("The operation was aborted.");
-      }
-      const path = request.url;
-      const method = request.method;
-      const route = routesTable.get(createRouteKey({ method, path }));
-      if (route !== undefined) {
-        const response = getYieldedValue(route.process.next())(request);
-        if (response.status >= 400 && throwOnNon2xxResponse) {
-          throw new RestError(
-            `Received unexpected HTTP status code ${response.status} while polling. This may indicate a server issue.`,
-            { statusCode: response.status },
-          );
-        }
-        return response;
-      }
-      const message = `Route for ${method} request to ${path} was not found`;
-      if (throwOnNon2xxResponse) {
-        throw new RestError(message, {
-          statusCode: 404,
-        });
-      }
-      return {
-        bodyAsText: JSON.stringify({ message }),
-        status: 404,
-        request,
-        headers: createHttpHeaders(),
-      };
-    },
-  };
-}
-
-function createSendOp(settings: {
-  client: HttpClient;
-}): (request: PipelineRequest) => Promise<OperationResponse<Result>> {
-  const { client } = settings;
-  return async function (request: PipelineRequest): Promise<OperationResponse<Result>> {
-    const response = await client.sendRequest(request);
-    const parsedBody: ResponseBody = response.bodyAsText
-      ? JSON.parse(response.bodyAsText)
-      : response.bodyAsText;
-    const headers = response.headers.toJSON();
-    return {
-      flatResponse: { ...parsedBody, ...headers, statusCode: response.status },
-      rawResponse: {
-        headers: headers,
-        statusCode: response.status,
-        body: parsedBody,
-        request,
-      },
-    };
-  };
-}
-
-export function createTestPoller(settings: {
-  routes: LroResponseSpec[];
-  resourceLocationConfig?: ResourceLocationConfig;
-  processResult?: (result: unknown, state: State) => Promise<Result> | Result;
-  updateState?: (state: State, lastResponse: OperationResponse<Result>) => void;
-  implName?: ImplementationName;
-  throwOnNon2xxResponse?: boolean;
-  restoreFrom?: string;
-}): PollerLike<State, Result> {
-  const {
-    routes,
-    resourceLocationConfig,
-    processResult,
-    updateState,
-    implName = "createPoller",
-    throwOnNon2xxResponse = true,
-    restoreFrom = undefined,
-  } = settings;
-  const client = createClient({ routes: toLroProcessors(routes), throwOnNon2xxResponse });
-  const { method: requestMethod, path = initialPath } = restoreFrom
-    ? { method: "GET" as HttpMethods, path: "FAKE" }
-    : routes[0];
-  const lro = createCoreRestPipelineLro({
-    sendOperationFn: createSendOp({ client }),
-    request: {
-      method: requestMethod,
-      url: path,
-      headers: createHttpHeaders(),
-      requestId: "",
-      timeout: 0,
-      withCredentials: false,
-    },
-  });
-  switch (implName) {
-    case "createPoller": {
-      return createHttpPoller(lro, {
-        intervalInMs: 0,
-        resourceLocationConfig: resourceLocationConfig,
-        processResult,
-        updateState: updateState as
-          | ((state: any, lastResponse: OperationResponse<unknown>) => void)
-          | undefined,
-        resolveOnUnsuccessful: !throwOnNon2xxResponse,
-        restoreFrom,
-      });
-    }
-    default: {
-      throw new Error("Unreachable");
-    }
-  }
-}
-
-async function runLro<TState>(settings: {
-  routes: LroResponseSpec[];
-  onProgress?: (state: TState) => void;
-  resourceLocationConfig?: ResourceLocationConfig;
-  processResult?: (result: unknown, state: TState) => Promise<Result> | Result;
-  updateState?: (state: TState, lastResponse: RawResponse) => void;
-  implName?: ImplementationName;
-  throwOnNon2xxResponse?: boolean;
-}): Promise<Result> {
-  const {
-    routes,
-    onProgress,
-    resourceLocationConfig,
-    processResult,
-    updateState,
-    implName = "createPoller",
-    throwOnNon2xxResponse = true,
-  } = settings;
-  const poller = createTestPoller({
-    routes,
-    resourceLocationConfig,
-    processResult,
-    updateState: (state, { rawResponse }) => updateState?.(state, rawResponse),
-    implName,
-    throwOnNon2xxResponse,
-  });
-  if (onProgress !== undefined) {
-    poller.onProgress(onProgress);
-  }
-  return poller.pollUntilDone();
-}
-
-export const createRunLroWith =
-  <TState>(variables: { implName: ImplementationName; throwOnNon2xxResponse?: boolean }) =>
-  (settings: {
-    routes: LroResponseSpec[];
-    onProgress?: (state: TState) => void;
-    resourceLocationConfig?: ResourceLocationConfig;
-    processResult?: (result: unknown, state: TState) => Result | Promise<Result>;
-    updateState?: (state: TState, lastResponse: RawResponse) => void;
-  }): Promise<Result> =>
-    runLro({ ...settings, ...variables });

package/test/utils/utils.ts

@@ -1,144 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import {
-  HttpMethods,
-  PipelineRequest,
-  PipelineResponse,
-  createHttpHeaders,
-  isRestError,
-} from "@azure/core-rest-pipeline";
-import { ResponseBody } from "../../src/http/models.js";
-import { assert } from "vitest";
-
-export interface RouteProcessor {
-  method: string;
-  path: string;
-  process: Generator<(request: PipelineRequest) => PipelineResponse>;
-}
-
-export interface LroResponseSpec {
-  method: HttpMethods;
-  path?: string;
-  status: number;
-  body?: string;
-  headers?: Record<string, string>;
-}
-
-export type ImplementationName = "createPoller";
-
-export type Result = ResponseBody & { statusCode: number };
-export type State = any;
-
-export function createProcessor(settings: {
-  status: number;
-  body?: string;
-  headers?: Record<string, string>;
-}): (req: PipelineRequest) => PipelineResponse {
-  const { status, body: bodyAsText, headers } = settings;
-  return (request: PipelineRequest) => ({
-    request,
-    headers: createHttpHeaders(headers),
-    status,
-    bodyAsText,
-  });
-}
-
-export function createDoubleHeaders(settings: {
-  pollingPath: string;
-  headers: Record<string, string>;
-}): Record<string, string> {
-  const { headers, pollingPath } = settings;
-  return {
-    "Azure-AsyncOperation": pollingPath,
-    Location: pollingPath,
-    ...headers,
-  };
-}
-
-export function* generate<T>(...input: T[]): Generator<T> {
-  for (const item of input) {
-    yield item;
-  }
-}
-
-export async function assertError(
-  error: Promise<unknown>,
-  options: {
-    statusCode?: number;
-    messagePattern?: RegExp;
-    name?: string;
-  } = {},
-): Promise<void> {
-  const { statusCode, messagePattern, name } = options;
-  try {
-    await error;
-    assert.fail(`Should have failed instead!`);
-  } catch (e: unknown) {
-    if (messagePattern) {
-      if (e instanceof Error) {
-        assert.match(e.message, messagePattern);
-      } else {
-        assert.fail(`Unexpected error: ${JSON.stringify(e)}`);
-      }
-    }
-    if (statusCode) {
-      if (isRestError(e)) {
-        assert.equal(e.statusCode, statusCode);
-      } else {
-        assert.fail(`Unexpected error: ${JSON.stringify(e)}`);
-      }
-    }
-    if (name) {
-      if (e instanceof Error) {
-        assert.equal(e.name, name);
-      } else {
-        assert.fail(`Unexpected error: ${JSON.stringify(e)}`);
-      }
-    }
-  }
-}
-
-export async function assertDivergentBehavior(inputs: {
-  op: Promise<Result>;
-  throwOnNon2xxResponse: boolean;
-  throwing: {
-    statusCode?: number;
-    messagePattern?: RegExp;
-  };
-  notThrowing: {
-    result?: any;
-    partResult?: any;
-    statusCode?: number;
-    messagePattern?: RegExp;
-  };
-}): Promise<void> {
-  const {
-    op,
-    throwOnNon2xxResponse,
-    throwing: { messagePattern, statusCode },
-    notThrowing: {
-      messagePattern: notThrowingMessagePattern,
-      statusCode: notThrowingStatusCode,
-      result,
-      partResult,
-    },
-  } = inputs;
-  if (throwOnNon2xxResponse) {
-    await assertError(op, {
-      statusCode,
-      messagePattern,
-    });
-  } else {
-    if (notThrowingStatusCode !== undefined || notThrowingMessagePattern !== undefined) {
-      await assertError(op, {
-        statusCode: notThrowingStatusCode,
-        messagePattern: notThrowingMessagePattern,
-      });
-    } else if (partResult !== undefined) {
-      assert.deepInclude(await op, partResult);
-    } else {
-      assert.deepEqual(await op, result);
-    }
-  }
-}

package/tsconfig.browser.config.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./.tshy/build.json",
-  "include": ["./src/**/*.ts", "./src/**/*.mts", "./test/**/*.spec.ts"],
-  "exclude": ["./test/**/node/**/*.ts"],
-  "compilerOptions": {
-    "outDir": "./dist-test/browser",
-    "rootDir": ".",
-    "skipLibCheck": true
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../tsconfig.package",
-  "compilerOptions": {
-    "paths": {
-      "@azure/core-lro": ["./src/index.ts"]
-    },
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "rootDir": "."
-  },
-  "exclude": ["./samples/**/*.ts"],
-  "include": ["./src/**/*.ts", "./src/**/*.mts", "./test/**/*.ts"]
-}

package/tsdoc.json

@@ -1,4 +0,0 @@
-{
-  "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
-  "extends": ["../../../tsdoc.json"]
-}

package/tslint.json

@@ -1,47 +0,0 @@
-{
-  "rules": {
-    "class-name": true,
-    "comment-format": [true, "check-space"],
-    "indent": [true, "spaces"],
-    "linebreak-style": [true, "LF"],
-    "one-line": [true, "check-open-brace", "check-whitespace"],
-    "no-var-keyword": true,
-    "quotemark": [true, "double", "avoid-escape"],
-    "semicolon": [true, "always", "ignore-bound-class-methods"],
-    "whitespace": [
-      true,
-      "check-branch",
-      "check-decl",
-      "check-operator",
-      "check-module",
-      "check-separator",
-      "check-type"
-    ],
-    "typedef-whitespace": [
-      true,
-      {
-        "call-signature": "nospace",
-        "index-signature": "nospace",
-        "parameter": "nospace",
-        "property-declaration": "nospace",
-        "variable-declaration": "nospace"
-      },
-      {
-        "call-signature": "onespace",
-        "index-signature": "onespace",
-        "parameter": "onespace",
-        "property-declaration": "onespace",
-        "variable-declaration": "onespace"
-      }
-    ],
-    "no-internal-module": true,
-    "jsdoc-format": true,
-    "no-inferrable-types": [true],
-    "no-null-keyword": true,
-    "no-return-await": true,
-    "no-switch-case-fall-through": true,
-    "no-trailing-whitespace": true,
-    "prefer-const": true,
-    "triple-equals": [true, "allow-undefined-check"]
-  }
-}

package/vitest.browser.config.ts

@@ -1,34 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    reporters: ["basic", "junit"],
-    outputFile: {
-      junit: "test-results.browser.xml",
-    },
-    browser: {
-      enabled: true,
-      headless: true,
-      name: "chromium",
-      provider: "playwright",
-    },
-    fakeTimers: {
-      toFake: ["setTimeout", "Date"],
-    },
-    watch: false,
-    include: ["dist-test/browser/**/*.spec.js"],
-    coverage: {
-      include: ["dist-test/browser/**/*.js"],
-      exclude: [
-        "dist-test/browser/**/*./*-browser.mjs",
-        "dist-test/browser/**/*./*-react-native.mjs",
-      ],
-      provider: "istanbul",
-      reporter: ["text", "json", "html"],
-      reportsDirectory: "coverage-browser",
-    },
-  },
-});

package/vitest.config.ts

@@ -1,31 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    reporters: ["basic", "junit"],
-    outputFile: {
-      junit: "test-results.browser.xml",
-    },
-    fakeTimers: {
-      toFake: ["setTimeout", "Date"],
-    },
-    watch: false,
-    include: ["test/**/*.spec.ts"],
-    exclude: ["test/**/browser/*.spec.ts"],
-    coverage: {
-      include: ["src/**/*.ts"],
-      exclude: [
-        "src/**/*-browser.mts",
-        "src/**/*-react-native.mts",
-        "vitest*.config.ts",
-        "samples-dev/**/*.ts",
-      ],
-      provider: "v8",
-      reporter: ["text", "json", "html"],
-      reportsDirectory: "coverage",
-    },
-  },
-});