feat(test): adds and cover the utility functions for testing actual and expected responses

.github/workflows/main.yml

@@ -27,7 +27,7 @@ jobs:
         run: yarn build
 
       - name: Test
-        run: yarn test --ci --coverage --maxWorkers=2
+        run: yarn test
 
       - name: Lint
         run: yarn lint
@@ -49,4 +49,5 @@ jobs:
             ${{github.workspace}}/packages/http-headers/coverage/lcov.info:lcov
             ${{github.workspace}}/packages/http-query/coverage/lcov.info:lcov
             ${{github.workspace}}/packages/oauth-adapters/coverage/lcov.info:lcov
-            ${{github.workspace}}/packages/schema/coverage/lcov.info:lcov
+            ${{github.workspace}}/packages/schema/coverage/lcov.info:lcov
+            ${{github.workspace}}/packages/test-helper/coverage/lcov.info:lcov

README.md

@@ -22,6 +22,7 @@ They provide common runtime utilities needed by SDKs to make API calls and handl
 | [@apimatic/http-query](packages/http-query) | HTTP Query utilities for apimatic-js-runtime libraries |
 | [@apimatic/oauth-adapters](packages/oauth-adapters) | Provides pluggable adapters for OAuth 2.0 authentication schemes. |
 | [@apimatic/xml-adapter](packages/xml-adapter) | Provides XML serialization and deserialization utilities for apimatic-js-runtime libraries. |
+| [@apimatic/test-helper](packages/test-helper) | Provides assertion utilities for testing api calls. It can be plugged in as dev dependency to any library. |
 
 [ci-badge]: https://github.com/apimatic/apimatic-js-runtime/actions/workflows/main.yml/badge.svg
 [ci-url]: https://github.com/apimatic/apimatic-js-runtime/actions/workflows/main.yml

packages/core-interfaces/src/httpClient.ts

@@ -0,0 +1,15 @@
+import { HttpRequest, RequestOptions } from './httpRequest';
+import { HttpResponse } from './httpResponse';
+
+/**
+ * Interface defining the contract for an HTTP client.
+ * Implementations of this interface should handle making HTTP requests
+ * and returning promises that resolve to HTTP responses.
+ * @param request The HTTP request to be sent.
+ * @param requestOptions Optional additional options for the request.
+ * @returns A promise that resolves to an HTTP response.
+ */
+export type HttpClientInterface = (
+  request: HttpRequest,
+  requestOptions?: RequestOptions
+) => Promise<HttpResponse>;

packages/core-interfaces/src/index.ts

@@ -1,6 +1,7 @@
 export * from './apiResponse';
 export * from './authentication';
 export * from './httpContext';
+export * from './httpClient';
 export * from './httpInterceptor';
 export * from './httpRequest';
 export * from './httpResponse';

packages/core/src/http/requestBuilder.ts

@@ -9,16 +9,17 @@ import {
   HttpRequest,
   HttpRequestMultipartFormBody,
   HttpRequestUrlEncodedFormBody,
-  HttpResponse,
   HttpInterceptorInterface,
   RequestOptions,
   RetryConfiguration,
   ApiLoggerInterface,
+  HttpClientInterface,
 } from '../coreInterfaces';
 import { ArgumentsValidationError } from '../errors/argumentsValidationError';
 import { ResponseValidationError } from '../errors/responseValidationError';
 import {
   Schema,
+  SchemaValidationError,
   validateAndMap,
   validateAndMapXml,
   validateAndUnmapXml,
@@ -81,11 +82,6 @@ export function skipEncode<T extends PathTemplatePrimitiveTypes>(
   return new SkipEncode(value);
 }
 
-export type HttpClientInterface = (
-  request: HttpRequest,
-  requestOptions?: RequestOptions
-) => Promise<HttpResponse>;
-
 export type ApiErrorConstructor = new (
   response: HttpContext,
   message: string
@@ -120,7 +116,7 @@ export interface RequestBuilder<BaseUrlParamType, AuthParams> {
   headers(headersToMerge: Record<string, string>): void;
   query(
     name: string,
-    value: QueryValue,
+    value: QueryValue | Record<string, QueryValue>,
     prefixFormat?: ArrayPrefixFunction
   ): void;
   query(
@@ -135,7 +131,7 @@ export interface RequestBuilder<BaseUrlParamType, AuthParams> {
     parameters: Record<string, unknown>,
     prefixFormat?: ArrayPrefixFunction
   ): void;
-  text(body: string): void;
+  text(body: string | number | bigint | boolean | null | undefined): void;
   json(data: unknown): void;
   requestRetryOption(option: RequestRetryOption): void;
   xml<T>(
@@ -289,7 +285,7 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
   }
   public query(
     name: string,
-    value: QueryValue,
+    value: QueryValue | Record<string, QueryValue>,
     prefixFormat?: ArrayPrefixFunction
   ): void;
   public query(
@@ -317,8 +313,10 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
       this._query.push(queryString);
     }
   }
-  public text(body: string): void {
-    this._body = body;
+  public text(
+    body: string | number | bigint | boolean | null | undefined
+  ): void {
+    this._body = body?.toString() ?? undefined;
     this._setContentTypeIfNotSet(TEXT_CONTENT_TYPE);
   }
   public json(data: unknown): void {
@@ -499,41 +497,9 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
       return { ...request, headers };
     });
     const result = await this.call(requestOptions);
-    if (typeof result.body !== 'string') {
-      throw new Error(
-        'Could not parse body as JSON. The response body is not a string.'
-      );
-    }
-    if (result.body.trim() === '') {
-      // Try mapping the missing body as null
-      return this.tryMappingAsNull<T>(schema, result);
-    }
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(result.body);
-    } catch (error) {
-      throw new Error(`Could not parse body as JSON.\n\n${error.message}`);
-    }
-    const mappingResult = validateAndMap(parsed, schema);
-    if (mappingResult.errors) {
-      throw new ResponseValidationError(result, mappingResult.errors);
-    }
-    return { ...result, result: mappingResult.result };
-  }
 
-  private tryMappingAsNull<T>(
-    schema: Schema<T, any>,
-    result: ApiResponse<void>
-  ) {
-    const nullMappingResult = validateAndMap(null, schema);
-    if (nullMappingResult.errors) {
-      throw new Error(
-        'Could not parse body as JSON. The response body is empty.'
-      );
-    }
-    return { ...result, result: nullMappingResult.result };
+    return { ...result, result: parseJsonResult(schema, result) };
   }
-
   public async callAsXml<T>(
     rootName: string,
     schema: Schema<T, any>,
@@ -593,7 +559,6 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
       return context;
     });
   }
-
   private _addApiLoggerInterceptors(): void {
     if (this._apiLogger) {
       const apiLogger = this._apiLogger;
@@ -606,14 +571,12 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
       });
     }
   }
-
   private _addAuthentication() {
     this.intercept((...args) => {
       const handler = this._authenticationProvider(this._authParams);
       return handler(...args);
     });
   }
-
   private _addRetryInterceptor() {
     this.intercept(async (request, options, next) => {
       let context: HttpContext | undefined;
@@ -659,7 +622,6 @@ export class DefaultRequestBuilder<BaseUrlParamType, AuthParams>
       return { request, response: context.response };
     });
   }
-
   private _addErrorHandlingInterceptor() {
     this.interceptResponse((context) => {
       const { response } = context;
@@ -720,3 +682,39 @@ function mergePath(left: string, right?: string): string {
     return `${left}/${right}`;
   }
 }
+function parseJsonResult<T>(schema: Schema<T, any>, res: ApiResponse<void>): T {
+  if (typeof res.body !== 'string') {
+    throw new Error(
+      'Could not parse body as JSON. The response body is not a string.'
+    );
+  }
+  if (res.body.trim() === '') {
+    const resEmptyErr = new Error(
+      'Could not parse body as JSON. The response body is empty.'
+    );
+    return validateJson(schema, null, (_) => resEmptyErr);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(res.body);
+  } catch (error) {
+    const resUnParseErr = new Error(
+      `Could not parse body as JSON.\n\n${error.message}`
+    );
+    return validateJson(schema, res.body, (_) => resUnParseErr);
+  }
+  const resInvalidErr = (errors: SchemaValidationError[]) =>
+    new ResponseValidationError(res, errors);
+  return validateJson(schema, parsed, (errors) => resInvalidErr(errors));
+}
+function validateJson<T>(
+  schema: Schema<T, any>,
+  value: any,
+  errorCreater: (errors: SchemaValidationError[]) => Error
+): T {
+  const mappingResult = validateAndMap(value, schema);
+  if (mappingResult.errors) {
+    throw errorCreater(mappingResult.errors);
+  }
+  return mappingResult.result;
+}

packages/core/test/http/requestBuilder.test.ts

@@ -1,11 +1,11 @@
 import {
-  HttpClientInterface,
   RequestBuilder,
   createRequestBuilderFactory,
   skipEncode,
 } from '../../src/http/requestBuilder';
 import {
   AuthenticatorInterface,
+  HttpClientInterface,
   HttpMethod,
   HttpRequest,
   HttpResponse,

packages/schema/src/types/discriminatedObject.ts

@@ -1,4 +1,9 @@
-import { Schema, SchemaMappedType, SchemaType } from '../schema';
+import {
+  Schema,
+  SchemaMappedType,
+  SchemaType,
+  SchemaValidationError,
+} from '../schema';
 import { objectEntries } from '../utils';
 import { ObjectXmlOptions } from './object';
 
@@ -14,9 +19,11 @@ export function discriminatedObject<
   defaultDiscriminator: keyof TDiscrimMap,
   xmlOptions?: ObjectXmlOptions
 ): Schema<any, any> {
-  const schemaSelector = (
+  const allSchemas = Object.values(discriminatorMap).reverse();
+  const selectSchema = (
     value: unknown,
     discriminatorProp: string | TDiscrimProp | TDiscrimMappedProp,
+    checker: (schema: TSchema) => SchemaValidationError[],
     isAttr: boolean = false
   ) => {
     if (
@@ -39,41 +46,53 @@ export function discriminatedObject<
         return discriminatorMap[discriminatorValue];
       }
     }
+    for (const key in allSchemas) {
+      if (checker(allSchemas[key]).length === 0) {
+        return allSchemas[key];
+      }
+    }
     return discriminatorMap[defaultDiscriminator];
   };
+
   return {
     type: () =>
-      `DiscriminatedUnion<${discriminatorPropName},[${objectEntries(
+      `DiscriminatedUnion<${discriminatorPropName as string},[${objectEntries(
         discriminatorMap
       )
         .map(([_, v]) => v.type)
         .join(',')}]>`,
     map: (value, ctxt) =>
-      schemaSelector(value, discriminatorPropName).map(value, ctxt),
+      selectSchema(value, discriminatorPropName, (schema) =>
+        schema.validateBeforeMap(value, ctxt)
+      ).map(value, ctxt),
     unmap: (value, ctxt) =>
-      schemaSelector(value, discriminatorMappedPropName).unmap(value, ctxt),
+      selectSchema(value, discriminatorMappedPropName, (schema) =>
+        schema.validateBeforeUnmap(value, ctxt)
+      ).unmap(value, ctxt),
     validateBeforeMap: (value, ctxt) =>
-      schemaSelector(value, discriminatorPropName).validateBeforeMap(
-        value,
-        ctxt
-      ),
+      selectSchema(value, discriminatorPropName, (schema) =>
+        schema.validateBeforeMap(value, ctxt)
+      ).validateBeforeMap(value, ctxt),
     validateBeforeUnmap: (value, ctxt) =>
-      schemaSelector(value, discriminatorMappedPropName).validateBeforeUnmap(
-        value,
-        ctxt
-      ),
+      selectSchema(value, discriminatorMappedPropName, (schema) =>
+        schema.validateBeforeUnmap(value, ctxt)
+      ).validateBeforeUnmap(value, ctxt),
     mapXml: (value, ctxt) =>
-      schemaSelector(
+      selectSchema(
         value,
         xmlOptions?.xmlName ?? discriminatorPropName,
+        (schema) => schema.validateBeforeMapXml(value, ctxt),
         xmlOptions?.isAttr
       ).mapXml(value, ctxt),
     unmapXml: (value, ctxt) =>
-      schemaSelector(value, discriminatorMappedPropName).unmapXml(value, ctxt),
+      selectSchema(value, discriminatorMappedPropName, (schema) =>
+        schema.validateBeforeUnmap(value, ctxt)
+      ).unmapXml(value, ctxt),
     validateBeforeMapXml: (value, ctxt) =>
-      schemaSelector(
+      selectSchema(
         value,
         xmlOptions?.xmlName ?? discriminatorPropName,
+        (schema) => schema.validateBeforeMapXml(value, ctxt),
         xmlOptions?.isAttr
       ).validateBeforeMapXml(value, ctxt),
   };

packages/schema/src/types/object.ts

@@ -377,7 +377,10 @@ function validateValueObject({
             ctxt.createChild(propTypePrefix + key, valueObject[key], schema)
           )
         );
-      } else if (schema.type().indexOf('Optional<') !== 0) {
+      } else if (
+        !schema.type().startsWith('Optional<') &&
+        !schema.type().startsWith('Nullable<')
+      ) {
         // Add to missing keys if it is not an optional property
         missingProps.add(key);
       }