@api-client/core 0.3.5 → 0.3.6

package/src/lib/fs/Fs.ts

@@ -0,0 +1,258 @@
+import { writeFile, mkdir, rm, readdir, stat, access, readFile, copyFile as fsCopyFile } from 'fs/promises';
+import { constants } from 'fs';
+import { join, dirname } from 'path';
+
+export interface JsonReadOptions {
+  /**
+   * Whether it should throw an error when a reading error occurs.
+   */
+  throws?: boolean;
+}
+
+// function statPromise(filePath: string): Promise<fsSync.Stats> {
+//   return new Promise((resolve, reject) => {
+//     fsSync.stat(filePath, (err, stats) => {
+//       if (err) {
+//         reject(err);
+//       } else {
+//         resolve(stats);
+//       }
+//     });
+//   });
+// }
+
+/**
+ * Checks whether a file exists in the location.
+ */
+export async function pathExists(filePath: string): Promise<boolean> {
+  // return new Promise((resolve) => {
+  //   fsSync.stat(filePath, (err, stats) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await stat(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tests a user's permissions for the file or directory specified by filePath.
+ * @param filePath The path to test
+ * @returns True when the path can be read by the current user.  
+ */
+export async function canRead(filePath: string): Promise<boolean> {
+  const exists = await pathExists(filePath);
+  if (!exists) {
+    return false;
+  }
+  
+  // return new Promise((resolve) => {
+  //   fsSync.access(filePath, constants.R_OK, (err) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await access(filePath, constants.R_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tests a user's permissions for the file or directory specified by filePath.
+ * @param filePath The path to test
+ * @returns True when the path can be written to by the current user.  
+ */
+export async function canWrite(filePath: string): Promise<boolean> {
+  const exists = await pathExists(filePath);
+  if (!exists) {
+    return false;
+  }
+  // return new Promise((resolve) => {
+  //   fsSync.access(filePath, constants.W_OK, (err) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await access(filePath, constants.W_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Reads the contents of a JSON file.
+ * 
+ * @param filePath The path to the JSON file to read.
+ * @returns The contents of the file. When `throws` options is not set and error occurs then it returns an empty file.
+ */
+export async function readJson(filePath: string, opts: JsonReadOptions={}): Promise<unknown> {
+  const readable = await canRead(filePath);
+  if (!readable) {
+    if (opts.throws) {
+      throw new Error(`Unable to read file: ${filePath}. Access is denied.`);
+    }
+    return {};
+  }
+  // return new Promise((resolve, reject) => {
+  //   fsSync.readFile(filePath, 'utf8', (err, contents) => {
+  //     if (err) {
+  //       reject(err);
+  //     } else {
+  //       let data = {};
+  //       try {
+  //         data = JSON.parse(contents);
+  //       } catch (e) {
+  //         if (opts.throws) {
+  //           const err = new Error(`Invalid JSON contents for file: ${filePath}.`);
+  //           reject(err);
+  //           return;
+  //         }
+  //       }
+  //       resolve(data);
+  //     }
+  //   });
+  // });
+  const contents = await readFile(filePath, 'utf8');
+  let data = {};
+  try {
+    data = JSON.parse(contents);
+  } catch (e) {
+    if (opts.throws) {
+      throw new Error(`Invalid JSON contents for file: ${filePath}.`);
+    }
+  }
+  return data;
+}
+
+/**
+ * Writes the contents to the file.
+ * 
+ * @param filePath The file to write to. It replaces the contents.
+ * @param contents The contents to write.
+ */
+export async function writeJson(filePath: string, contents: string|any): Promise<void> {
+  const destParent = dirname(filePath);
+  await ensureDir(destParent);
+  const parentWritable = await canWrite(destParent);
+  if (!parentWritable) {
+    throw new Error(`Unable to write to location: ${parentWritable}. Access is denied.`);
+  }
+  const data = typeof contents === 'string' ? contents : JSON.stringify(contents);
+  await writeFile(filePath, data);
+}
+
+/**
+ * Ensures the directory exists.
+ */
+export async function ensureDir(dirPath: string): Promise<void> {
+  const readable = await canRead(dirPath);
+  if (readable) {
+    return;
+  }
+  await mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Removes contents of the directory, leaving the directory in the filesystem.
+ */
+export async function emptyDir(dirPath: string): Promise<void> {
+  const exists = await pathExists(dirPath);
+  if (!exists) {
+    return;
+  }
+  const writeable = await canWrite(dirPath);
+  if (!writeable) {
+    throw new Error(`Unable to clear directory: ${dirPath}. Access is denied.`);
+  }
+  const items = await readdir(dirPath, 'utf8');
+  for (const item of items) {
+    const file = join(dirPath, item);
+    await rm(file, { recursive: true });
+  }
+}
+
+/**
+ * Copies a file
+ */
+async function copyFile(source: string, dest: string): Promise<void> {
+  const destParent = dirname(dest);
+  await ensureDir(destParent);
+  await fsCopyFile(source, dest);
+}
+
+// /**
+//  * Copies a file
+//  * @param {string} source 
+//  * @param {string} dest 
+//  * @returns {Promise<void>}
+//  */
+// async function copyFile(source, dest) {
+//   const destParent = dirname(dest);
+//   await ensureDir(destParent);
+//   return new Promise((resolve, reject) => {
+//     fsSync.copyFile(source, dest, (err) => {
+//       if (err) {
+//         reject(err);
+//       } else {
+//         resolve();
+//       }
+//     });
+//   });
+// }
+
+/**
+ * Copies a directory and its contents.
+ */
+async function copyDirectory(source: string, dest: string): Promise<void> {
+  await ensureDir(dest);
+  // const entries = fsSync.readdirSync(source, { withFileTypes: true, encoding: 'utf8' });
+  const entries = await readdir(source, { withFileTypes: true, encoding: 'utf8' });
+  for (const entry of entries) {
+    const srcFile = join(source, entry.name);
+    const destFile = join(dest, entry.name);
+    const srcStat = await stat(srcFile);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcFile, destFile);
+    } else {
+      await copyFile(srcFile, destFile);
+    }
+  }
+}
+
+/**
+ * Copies a file or a directory to the destination location.
+ * It creates the destination folder when missing.
+ * 
+ * @param source The source file or folder.
+ * @param dest The destination file or folder.
+ */
+export async function copy(source: string, dest: string): Promise<void> {
+  const existing = await pathExists(source);
+  if (!existing) {
+    throw new Error(`Specified path does not exist: ${source}`);
+  }
+  const srcStat = await stat(source);
+  if (srcStat.isDirectory()) {
+    await copyDirectory(source, dest);
+  } else {
+    await copyFile(source, dest);
+  }
+}

package/src/lib/timers/Timers.ts

@@ -0,0 +1,9 @@
+/**
+ * Awaits the set number of milliseconds before resolving the promise.
+ * @param timeout The number of milliseconds to wait.
+ */
+export function sleep(timeout = 0): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), timeout);
+  });
+}

package/src/mocking/LegacyInterfaces.ts

@@ -1,4 +1,4 @@
-import { DataMockInit, HarTimingInit, HttpRequestInit, HttpResponseRedirectStatusInit } from '@pawel-up/data-mock/types'
+import { DataMockInit, HarTimingInit, HttpResponseRedirectStatusInit } from '@pawel-up/data-mock/types'
 
 export interface ArcDataMockInit extends DataMockInit {
 }

package/src/mocking/ProjectMock.ts

@@ -0,0 +1,20 @@
+import { DataMock, DataMockInit } from '@pawel-up/data-mock';
+import { Request } from './lib/Request.js';
+import { Response } from './lib/Response.js';
+
+export { IRequestLogInit } from './lib/Request.js';
+export { IArcResponseInit } from './lib/Response.js';
+
+export class ProjectMock extends DataMock {
+  projectRequest: Request;
+  response: Response;
+  
+  /**
+   * @param init The library init options.
+   */
+  constructor(init?: DataMockInit) {
+    super(init);
+    this.projectRequest = new Request(init);
+    this.response = new Response(init);
+  }
+}

package/src/mocking/lib/Request.ts

@@ -0,0 +1,85 @@
+import { Http, Types, Lorem, Time, DataMockInit, HttpRequestInit } from '@pawel-up/data-mock';
+// import { randomValue } from '@pawel-up/data-mock/src/lib/Http.js';
+import { IHttpRequest, Kind as HttpRequestKind } from '../../models/HttpRequest.js';
+import { IRequest, Kind as RequestKind } from '../../models/Request.js';
+import { ISentRequest } from '../../models/SentRequest.js';
+import { IRequestLog } from '../../models/RequestLog.js';
+import { IArcResponseInit, Response } from './Response.js';
+
+export interface IRequestLogInit {
+  request?: HttpRequestInit;
+  response?: IArcResponseInit;
+  /**
+   * When set it ignores size information
+   */
+  noSize?: boolean;
+  /**
+   * Adds redirects to the request
+   */
+  redirects?: boolean;
+  noResponse?: boolean;
+  noRequest?: boolean;
+}
+
+export class Request {
+  types: Types;
+  lorem: Lorem;
+  time: Time;
+  http: Http;
+  response: Response;
+
+  constructor(init: DataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.time = new Time(init);
+    this.http = new Http(init);
+    this.response = new Response(init);
+  }
+
+  request(init?: HttpRequestInit): IRequest {
+    return {
+      kind: RequestKind,
+      expects: this.httpRequest(init),
+      info: {
+        name: this.lorem.words(2),
+        description: this.lorem.paragraph(),
+      },
+    }
+  }
+
+  httpRequest(init?: HttpRequestInit): IHttpRequest {
+    const request = this.http.request(init);
+    return {
+      kind: HttpRequestKind,
+      ...request,
+    }
+  }
+
+  sentRequest(init?: HttpRequestInit): ISentRequest {
+    const start = this.time.timestamp();
+    return {
+      startTime: start,
+      endTime: this.time.timestamp({ min: start + 1 }),
+      ...this.httpRequest(init),
+    };
+  }
+
+  log(init: IRequestLogInit = {}): IRequestLog {
+    const result: IRequestLog = {
+      kind: 'ARC#ResponseLog',
+    };
+    if (!init.noRequest) {
+      result.request = this.sentRequest(init.request);
+    }
+    if (!init.noResponse) {
+      result.response = this.response.arcResponse(init.response);
+    }
+    if (init.redirects) {
+      result.redirects = this.response.redirects();
+    }
+    if (!init.noSize) {
+      result.size = this.response.size();
+    }
+    return result;
+  }
+}

package/src/mocking/lib/Response.ts

@@ -0,0 +1,101 @@
+import { Http, Har, Types, Lorem, Time, DataMockInit, HttpResponseInit, HarTimingInit, Internet } from '@pawel-up/data-mock';
+import { IHttpResponse, Kind as HttpResponseKind } from '../../models/HttpResponse.js';
+import { IArcResponse, Kind as ArcResponseKind } from '../../models/ArcResponse.js';
+import { IRequestsSize } from '../../models/RequestsSize.js';
+import { IResponseRedirect, Kind as ResponseRedirectKind  } from '../../models/ResponseRedirect.js';
+
+export interface IArcResponseInit extends HttpResponseInit, HarTimingInit {
+  /**
+   * When set it does not generate a response payload.
+   */
+  noBody?: boolean;
+  /**
+   * The first number of the status group. Other 2 are auto generated
+   */
+  statusGroup?: number;
+  /**
+   * Whether to generate timings object
+   */
+  timings?: boolean;
+}
+
+export class Response {
+  types: Types;
+  lorem: Lorem;
+  time: Time;
+  http: Http;
+  har: Har;
+  internet: Internet;
+
+  constructor(init: DataMockInit={}) {
+    this.types = new Types(init.seed);
+    this.lorem = new Lorem(init);
+    this.time = new Time(init);
+    this.http = new Http(init);
+    this.har = new Har(init);
+    this.internet = new Internet(init);
+  }
+
+  response(init: IArcResponseInit = {}): IHttpResponse {
+    const ct = init.noBody ? undefined : this.http.headers.contentType();
+    const body = init.noBody ? undefined : this.http.payload.payload(ct);
+    const headers = this.http.headers.headers('response', { mime: ct });
+    const statusGroup = init.statusGroup ? init.statusGroup : this.types.number({ min: 2, max: 5 });
+    const sCode = this.types.number({ min: 0, max: 99 }).toString();
+    const code = Number(`${statusGroup}${sCode.padStart(2, '0')}`);
+    const status = this.lorem.word();
+    const result: IHttpResponse = {
+      kind: HttpResponseKind,
+      status: code,
+      statusText: status,
+      headers,
+    };
+    if (!init.noBody) {
+      result.payload = body;
+    }
+    return result;
+  }
+
+  arcResponse(init: IArcResponseInit={}): IArcResponse {
+    const base = this.response(init);
+    const length = this.types.number({ min: 10, max: 4000 });
+    const result: IArcResponse = {
+      ...base,
+      kind: ArcResponseKind,
+      loadingTime: length,
+    };
+    if (init.timings) {
+      result.timings = this.har.timing(init);
+    }
+    return result;
+  }
+
+  size(): IRequestsSize {
+    const result: IRequestsSize = {
+      request: this.types.number({ min: 10 }),
+      response: this.types.number({ min: 10 }),
+    };
+    return result;
+  }
+
+  redirect(init?: IArcResponseInit): IResponseRedirect {
+    const start = this.time.timestamp();
+    const end = this.time.timestamp({ min: start + 1 })
+    const info: IResponseRedirect = {
+      kind: ResponseRedirectKind,
+      startTime: start,
+      endTime: end,
+      url: this.internet.uri(),
+      response: this.response({ ...init, statusGroup: 3}),
+    };
+    return info;
+  }
+
+  redirects(size=1, init?: IArcResponseInit): IResponseRedirect[] {
+    const result: IResponseRedirect[] = [];
+    for (let i = 0; i < size; i++) {
+      result.push(this.redirect(init));
+    }
+    return result;
+  }
+}

package/src/runtime/node/BaseRunner.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'events';
+import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/Reporter.js';
+
+export abstract class BaseRunner extends EventEmitter {
+  /**
+   * Iteration start time.
+   */
+  protected startTime?: number;
+  /**
+   * Iteration end time.
+   */
+  protected endTime?: number;
+  /**
+   * A list of already executed iterations.
+   */
+  protected executed: IProjectExecutionIteration[] = [];
+
+  /**
+   * Creates the report of the execution.
+   */
+  protected async createReport(): Promise<IProjectExecutionLog> {
+    const log: IProjectExecutionLog = {
+      started: this.startTime as number,
+      ended: this.endTime as number,
+      iterations: this.executed,
+    };
+    return log;
+  }
+}