@azure-tools/typespec-ts 0.11.0

package/test/unit/util/emitUtil.ts

@@ -0,0 +1,156 @@
+import { listClients } from "@azure-tools/typespec-client-generator-core";
+import {
+  buildClient,
+  buildClientDefinitions,
+  buildParameterTypes,
+  buildResponseTypes,
+  buildSchemaTypes,
+  ImportKind,
+  Schema
+} from "@azure-tools/rlc-common";
+import { createDpgContextTestHelper, rlcEmitterFor } from "./testUtil.js";
+import { transformToParameterTypes } from "../../../src/transform/transformParameters.js";
+import { transformSchemas } from "../../../src/transform/transformSchemas.js";
+import { transformPaths } from "../../../src/transform/transformPaths.js";
+import { transformUrlInfo } from "../../../src/transform/transform.js";
+import { transformApiVersionParam } from "../../../src/transform/transformApiVersionParam.js";
+import { transformToResponseTypes } from "../../../src/transform/transformResponses.js";
+import { getCredentialInfo } from "../../../src/transform/transfromRLCOptions.js";
+
+export async function emitModelsFromCadl(
+  cadlContent: string,
+  needAzureCore: boolean = false
+) {
+  const context = await rlcEmitterFor(cadlContent, true, needAzureCore);
+  const program = context.program;
+  const dpgContext = createDpgContextTestHelper(context.program);
+  const clients = listClients(dpgContext);
+  let rlcSchemas: Schema[] = [];
+  if (clients && clients[0]) {
+    rlcSchemas = transformSchemas(program, clients[0], dpgContext);
+  }
+  return buildSchemaTypes({
+    schemas: rlcSchemas,
+    srcPath: "",
+    paths: {},
+    libraryName: "test"
+  });
+}
+
+export async function emitParameterFromCadl(
+  cadlContent: string,
+  needAzureCore: boolean = false,
+  ignoreClientApiVersion: boolean = false
+) {
+  const context = await rlcEmitterFor(
+    cadlContent,
+    true,
+    needAzureCore,
+    ignoreClientApiVersion
+  );
+  const program = context.program;
+  const dpgContext = createDpgContextTestHelper(context.program);
+  const clients = listClients(dpgContext);
+  const importSet = new Map<ImportKind, Set<string>>();
+  let parameters;
+  if (clients && clients[0]) {
+    parameters = transformToParameterTypes(
+      program,
+      importSet,
+      clients[0],
+      dpgContext
+    );
+  }
+  return buildParameterTypes({
+    srcPath: "",
+    paths: {},
+    libraryName: "test",
+    schemas: [],
+    parameters,
+    importSet
+  });
+}
+
+export async function emitClientDefinitionFromCadl(
+  cadlContent: string,
+  needAzureCore: boolean = false
+) {
+  const context = await rlcEmitterFor(cadlContent, true, needAzureCore);
+  const program = context.program;
+  const dpgContext = createDpgContextTestHelper(context.program);
+  const clients = listClients(dpgContext);
+  let paths = {};
+  if (clients && clients[0]) {
+    paths = transformPaths(program, clients[0], dpgContext);
+  }
+  return buildClientDefinitions({
+    srcPath: "",
+    libraryName: "test",
+    schemas: [],
+    paths
+  });
+}
+
+export async function emitClientFactoryFromCadl(
+  cadlContent: string,
+  needAzureCore: boolean = false
+) {
+  const context = await rlcEmitterFor(cadlContent, false, needAzureCore);
+  const program = context.program;
+  const dpgContext = createDpgContextTestHelper(context.program);
+  const urlInfo = transformUrlInfo(program, dpgContext);
+  const creadentialInfo = getCredentialInfo(program, {});
+  const clients = listClients(dpgContext);
+  let apiVersionInQueryParam;
+  if (clients && clients[0]) {
+    apiVersionInQueryParam = transformApiVersionParam(
+      clients[0],
+      program,
+      dpgContext
+    );
+  }
+
+  return buildClient({
+    srcPath: "",
+    libraryName: "test",
+    schemas: [],
+    paths: {},
+    urlInfo,
+    apiVersionInQueryParam,
+    options: {
+      packageDetails: {
+        name: "test",
+        version: "1.0.0-beta.1"
+      },
+      ...creadentialInfo
+    }
+  });
+}
+
+export async function emitResponsesFromCadl(
+  cadlContent: string,
+  needAzureCore: boolean = false
+) {
+  const context = await rlcEmitterFor(cadlContent, true, needAzureCore);
+  const program = context.program;
+  const dpgContext = createDpgContextTestHelper(context.program);
+  const importSet = new Map<ImportKind, Set<string>>();
+  const clients = listClients(dpgContext);
+  let responses;
+  if (clients && clients[0]) {
+    responses = transformToResponseTypes(
+      program,
+      importSet,
+      clients[0],
+      dpgContext
+    );
+  }
+  return buildResponseTypes({
+    srcPath: "",
+    libraryName: "test",
+    schemas: [],
+    paths: {},
+    responses,
+    importSet
+  });
+}

package/test/unit/util/testUtil.ts

@@ -0,0 +1,83 @@
+import { Program } from "@typespec/compiler";
+import { createTestHost } from "@typespec/compiler/testing";
+import { TestHost } from "@typespec/compiler/testing";
+import { RestTestLibrary } from "@typespec/rest/testing";
+import { HttpTestLibrary } from "@typespec/http/testing";
+import { VersioningTestLibrary } from "@typespec/versioning/testing";
+import { AzureCoreTestLibrary } from "@azure-tools/typespec-azure-core/testing";
+import { DpgContext } from "@azure-tools/typespec-client-generator-core";
+import { assert } from "chai";
+import { format } from "prettier";
+import { prettierTypeScriptOptions } from "../../../src/lib.js";
+
+export async function createRLCEmitterTestHost() {
+  return createTestHost({
+    libraries: [
+      HttpTestLibrary,
+      RestTestLibrary,
+      VersioningTestLibrary,
+      AzureCoreTestLibrary
+    ]
+  });
+}
+
+export async function rlcEmitterFor(
+  code: string,
+  needNamespaces: boolean = true,
+  needAzureCore: boolean = false,
+  ignoreClientApiVersion: boolean = false
+): Promise<TestHost> {
+  const host: TestHost = await createRLCEmitterTestHost();
+  const namespace = `
+  @service({
+    title: "Azure TypeScript Testing",
+    ${ignoreClientApiVersion ? "" : 'version: "2022-12-16-preview",'}
+  })
+
+  namespace Azure.TypeScript.Testing;
+  `;
+  host.addTypeSpecFile(
+    "main.tsp",
+    `
+  import "@typespec/http";
+  import "@typespec/rest";
+  import "@typespec/versioning";
+  ${needAzureCore ? 'import "@azure-tools/typespec-azure-core";' : ""} 
+
+  using TypeSpec.Rest; 
+  using TypeSpec.Http;
+  using TypeSpec.Versioning;
+  ${needAzureCore ? "using Azure.Core;" : ""}
+  
+  ${needNamespaces ? namespace : ""}
+
+  ${code}
+  `
+  );
+  await host.compile("./", {
+    warningAsError: false
+  });
+  return host;
+}
+
+export function createDpgContextTestHelper(program: Program): DpgContext {
+  const defaultOptions = {
+    generateProtocolMethods: true,
+    generateConvenienceMethods: true,
+    emitters: []
+  };
+  const resolvedOptions = { ...defaultOptions };
+  program.emitters = resolvedOptions.emitters as any;
+  return {
+    program: program,
+    generateProtocolMethods: resolvedOptions.generateProtocolMethods,
+    generateConvenienceMethods: resolvedOptions.generateConvenienceMethods
+  } as DpgContext;
+}
+
+export function assertEqualContent(actual: string, expected: string) {
+  assert.strictEqual(
+    format(actual, prettierTypeScriptOptions),
+    format(expected, prettierTypeScriptOptions)
+  );
+}

package/test/util/customBearerTokenTestingPolicy.ts

@@ -0,0 +1,78 @@
+import { AccessToken, GetTokenOptions } from "@azure/core-auth";
+import {
+  AuthorizeRequestOptions,
+  BearerTokenAuthenticationPolicyOptions,
+  PipelinePolicy,
+  PipelineRequest,
+  PipelineResponse,
+  SendRequest
+} from "@azure/core-rest-pipeline";
+
+/**
+ * This is a customized policy used in testing
+ * In this policy we will set the bearer token header in request
+ * @param options Detailed options
+ * @returns A customized bearer auth policy
+ */
+export function customBearerTokenAuthenticationPolicy(
+  options: BearerTokenAuthenticationPolicyOptions
+): PipelinePolicy {
+  const { credential, scopes, challengeCallbacks } = options;
+  const callbacks = {
+    authorizeRequest:
+      challengeCallbacks?.authorizeRequest ?? defaultAuthorizeRequest,
+    // keep all other properties
+    ...challengeCallbacks
+  };
+
+  const getAccessToken = credential
+    ? (): Promise<AccessToken | null> => credential.getToken(scopes)
+    : () => Promise.resolve(null);
+
+  return {
+    name: "customBearerTokenAuthPolicy",
+    async sendRequest(
+      request: PipelineRequest,
+      next: SendRequest
+    ): Promise<PipelineResponse> {
+      await callbacks.authorizeRequest({
+        scopes: Array.isArray(scopes) ? scopes : [scopes],
+        request,
+        getAccessToken
+      });
+
+      let response: PipelineResponse;
+      let error: Error | undefined;
+      try {
+        response = await next(request);
+      } catch (err: any) {
+        error = err;
+        response = err.response;
+      }
+
+      if (error) {
+        throw error;
+      } else {
+        return response;
+      }
+    }
+  };
+}
+
+/**
+ * Default authorize request handler
+ */
+async function defaultAuthorizeRequest(
+  options: AuthorizeRequestOptions
+): Promise<void> {
+  const { scopes, getAccessToken, request } = options;
+  const getTokenOptions: GetTokenOptions = {
+    abortSignal: request.abortSignal,
+    tracingOptions: request.tracingOptions
+  };
+  const accessToken = await getAccessToken(scopes, getTokenOptions);
+
+  if (accessToken) {
+    options.request.headers.set("Authorization", `Bearer ${accessToken.token}`);
+  }
+}

package/test/util/matrix.ts

@@ -0,0 +1,48 @@
+// 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/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "./dist",
+    "composite": true,
+    "lib": ["ES2019"],
+    "target": "es2019",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "importHelpers": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
+  },
+  "ts-node": {
+    "esm": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "cadl-output"]
+}

package/tsconfig.test.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Node"
+  }
+}

package/typespec-ts.build.log

@@ -0,0 +1,2 @@
+Invoking: tsc -p . 
+