@thisisagile/easy-test 15.8.4 → 15.8.6

package/dist/index.d.mts

@@ -0,0 +1,379 @@
+import { AsymmetricMatcher } from 'expect';
+
+type OneOrMore<T> = T | Array<T>;
+type Constructor<T> = {
+    new (...args: any[]): T;
+};
+type Message<P> = Text | ((...params: P[]) => Text);
+type Validatable = {
+    isValid: boolean;
+};
+type Result = {
+    domain?: string;
+    location?: string;
+    message: string;
+};
+type Results = Validatable & {
+    results: Result[];
+};
+type Uri = Text;
+type Id = string | number;
+type JsonValue = string | number | boolean | null | Json | JsonValue[];
+type Json = {
+    [key: string]: JsonValue;
+};
+type Exception = {
+    id: Id;
+    reason?: string;
+};
+type Text = {
+    toString: () => string;
+};
+type Query = Text;
+type UseCase = {
+    app: {
+        id: Text;
+    };
+    id: Text;
+};
+type Tester = {
+    url: string;
+};
+
+type HttpStatus = {
+    name: string;
+    id: Id;
+};
+type RestResult = {
+    data?: {
+        code: number;
+        items: unknown[];
+        itemCount: number;
+    };
+    error?: {
+        code: number;
+        message: string;
+        errorCount: number;
+        errors: unknown[];
+    };
+};
+type Response = {
+    status: HttpStatus;
+    headers?: {
+        [key: string]: any;
+    };
+    body?: RestResult;
+};
+
+declare const toHaveStatus: (res: Response, code: number) => jest.CustomMatcherResult;
+declare const toBeOk: (res: Response) => jest.CustomMatcherResult;
+declare const toBeCreated: (res: Response) => jest.CustomMatcherResult;
+declare const toHaveNoContent: (res: Response) => jest.CustomMatcherResult;
+declare const toBeBadRequest: (res: Response) => jest.CustomMatcherResult;
+declare const toBeUnauthorized: (res: Response) => jest.CustomMatcherResult;
+declare const toBeForbidden: (res: Response) => jest.CustomMatcherResult;
+declare const toBeNotFound: (res: Response) => jest.CustomMatcherResult;
+declare const toBeConflict: (res: Response) => jest.CustomMatcherResult;
+declare const toBeInternalServerError: (res: Response) => jest.CustomMatcherResult;
+declare const toBeBadGateway: (res: Response) => jest.CustomMatcherResult;
+declare const toBeOkWithItems: (res: Response, length: number) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeOk(): R;
+            toBeOkWithItems(length: number): R;
+            toBeCreated(): R;
+            toHaveNoContent(): R;
+            toBeNotFound(): R;
+            toBeUnauthorized(): R;
+            toBeForbidden(): R;
+            toBeBadRequest(): R;
+            toBeConflict(): R;
+            toBeInternalServerError(): R;
+            toBeBadGateway(): R;
+            toHaveStatus(code: number): R;
+        }
+    }
+}
+
+declare class Match<S> {
+    private readonly subject;
+    private readonly failed;
+    private readonly message;
+    constructor(subject: S, failed?: boolean, message?: Message<S>);
+    not(p: (s: S) => boolean, message: Message<S>): Match<S>;
+    undefined(p: (s: S) => any, message: Message<S>): Match<S>;
+    else(message: Message<S>): jest.CustomMatcherResult;
+}
+declare const match: <S>(subject: S) => Match<S>;
+
+type ToMessage<S> = string | ((s: S[]) => string);
+declare class Check<S> {
+    private ctx;
+    private readonly received;
+    private readonly expected;
+    private readonly failed;
+    private readonly message;
+    constructor(ctx: jest.MatcherContext, received: S, expected: S, failed?: boolean, message?: string);
+    print(message: ToMessage<S>): string;
+    not(p: (s: S[]) => boolean, message: ToMessage<S>): Check<S>;
+    undefined(p: (s: S[]) => any, message: ToMessage<S>): Check<S>;
+    else(message?: ToMessage<S>): jest.CustomMatcherResult;
+}
+declare const check: <S>(ctx: jest.MatcherContext, received: S, expected?: S | undefined) => Check<S>;
+declare const checkDefined: <S>(ctx: jest.MatcherContext, received: S, expected?: S | undefined) => Check<S>;
+
+declare const toResultWith: (results: Results, message: string) => jest.CustomMatcherResult;
+declare const toFail: (results: Results) => jest.CustomMatcherResult;
+declare const toFailWith: (results: Results, message: string) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toResultWith(message: string): R;
+            toFail(): R;
+            toFailWith(message: string): R;
+        }
+    }
+}
+
+declare const toBeArrayOf: <T>(items: unknown, ctor: Constructor<T>) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeArrayOf<Z>(ctor: Constructor<Z>): R;
+        }
+    }
+}
+
+declare const toBeArrayOfWithLength: <T>(items: unknown, ctor: Constructor<T>, length: number) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeArrayOfWithLength<Z>(ctor: Constructor<Z>, length: number): R;
+        }
+    }
+}
+
+declare const toBeAt: (tester?: Tester, uc?: UseCase, id?: Id) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeAt(uc?: UseCase, id?: Id): R;
+        }
+    }
+}
+
+declare const toBeExactlyAt: (tester?: Tester, uc?: UseCase, id?: Id) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeExactlyAt(uc?: UseCase, id?: Id): R;
+        }
+    }
+}
+
+declare const Fails: {
+    Yes: string;
+    No: (reason: string) => string;
+};
+declare const FailsWith: {
+    Yes: string;
+    No: (message: string, instead: string) => string;
+};
+declare const toFailMatcher: (result: jest.CustomMatcherResult) => jest.CustomMatcherResult;
+declare const toFailMatcherWith: (result: jest.CustomMatcherResult, message: Message<jest.CustomMatcherResult>) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toFailMatcher(): R;
+            toFailMatcherWith(message: string): R;
+        }
+    }
+}
+
+declare const toBeValid: (v?: unknown) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeValid(): R;
+        }
+    }
+}
+
+declare function toMatchArray(this: jest.MatcherContext, received: any[], expected: any[]): jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchArray(expected: any[]): R;
+        }
+    }
+}
+
+declare const MatchesExactJson: {
+    SubjectUndefined: string;
+    SubsetUndefined: string;
+    DoesNotMatch: string;
+    Yes: string;
+};
+declare const toMatchExactJson: (value?: unknown, json?: unknown) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchExactJson(json?: unknown): R;
+        }
+    }
+}
+
+declare const toMatchException: (received: Exception, expected: unknown, reason?: string) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchException(exception: unknown, reason?: string): R;
+        }
+    }
+}
+
+declare const MatchesJson: {
+    SubjectUndefined: string;
+    SubsetUndefined: string;
+    DoesNotMatch: string;
+    Yes: string;
+};
+declare const toMatchJson: (value?: unknown, subset?: unknown) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchJson(subset?: unknown): R;
+        }
+    }
+}
+
+declare const toMatchRoute: (uri?: Uri, route?: Uri | string) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchRoute(route?: Uri | string): R;
+        }
+    }
+}
+
+declare const toMatchText: (value?: unknown, text?: unknown) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toMatchText(text?: unknown): R;
+        }
+    }
+}
+
+declare const Passes: {
+    Yes: string;
+    No: (reason: string) => string;
+};
+declare const PassesWith: {
+    Yes: string;
+    No: (message: string, instead: string) => string;
+};
+declare const toPassMatcher: (result: jest.CustomMatcherResult) => jest.CustomMatcherResult;
+declare const toPassMatcherWith: (result: jest.CustomMatcherResult, message: Message<jest.CustomMatcherResult>) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toPassMatcher(): R;
+            toPassMatcherWith(message: string): R;
+        }
+    }
+}
+
+declare const toBeQueriedWith: (query: jest.Mock, expected: Query) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeQueriedWith(expected: Query): R;
+        }
+    }
+}
+
+declare const toBeRoutedTo: (query: jest.Mock, expected: Uri) => jest.CustomMatcherResult;
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            toBeRoutedTo(uri: Uri): R;
+        }
+    }
+}
+
+declare class ObjectContainingText extends AsymmetricMatcher<string> {
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+}
+declare class ObjectContainingTextExact extends AsymmetricMatcher<string> {
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+}
+declare class ObjectContainingJson extends AsymmetricMatcher<any> {
+    asymmetricMatch(other: any): boolean;
+    toString(): string;
+}
+declare const fits: {
+    any: () => any;
+    type: (type?: unknown) => any;
+    with: (o: unknown) => any;
+    text: (s: any) => any;
+    textExact: (s: any) => any;
+    uri: (u: Uri) => any;
+    json: (s: any) => any;
+    items: (...items: any[]) => any;
+};
+
+declare class Req {
+    readonly state: any;
+    constructor(state?: any);
+    get id(): Id;
+    get q(): JsonValue;
+    get path(): Json;
+    get query(): Json;
+    get skip(): number | undefined;
+    get take(): number | undefined;
+    get body(): unknown;
+    get headers(): Record<string, OneOrMore<string>>;
+    get: (key: Text) => any;
+}
+
+declare class Mocks {
+    clear: () => typeof jest;
+    impl: (f?: ((...args: any[]) => any) | undefined) => jest.Mock;
+    property: <T extends object, P extends keyof { [K in keyof Required<T> as Required<T>[K] extends jest.Func ? never : K]: Required<T>[K]; }>(object: T, getter: P, value: T[P]) => jest.SpyInstance;
+    reject: (value?: unknown) => jest.Mock;
+    rejectWith: <T = any>(props?: Partial<T>) => jest.Mock;
+    req: {
+        id: (id: Id) => Req;
+        q: (q: unknown) => Req;
+        with: (a: Json) => Req;
+        body: (body: unknown) => Req;
+        path: (path: Json) => Req;
+        query: (query: Json) => Req;
+    };
+    resp: {
+        items: (status: HttpStatus, items?: unknown[]) => Response;
+        errors: (status: HttpStatus, message: string, errors?: unknown[]) => Response;
+    };
+    resolve: (value?: unknown) => jest.Mock;
+    resolveWith: <T = any>(props?: Partial<T>) => jest.Mock;
+    return: (value?: unknown) => jest.Mock;
+    returnWith: <T = any>(props?: Partial<T>) => jest.Mock;
+    this: () => jest.Mock;
+    provider: {
+        data: (...items: any[]) => {
+            execute: jest.Mock;
+        };
+    };
+    empty: <T = any>(props?: Partial<T>) => T;
+    a: <T = any>(props?: Partial<T>) => T;
+    an: <T = any>(props?: Partial<T>) => T;
+    date: (epoch?: number) => Date;
+    once: (...values: unknown[]) => jest.Mock;
+}
+declare const mock: Mocks;
+
+export { Fails, FailsWith, Match, MatchesExactJson, MatchesJson, Mocks, ObjectContainingJson, ObjectContainingText, ObjectContainingTextExact, Passes, PassesWith, check, checkDefined, fits, match, mock, toBeArrayOf, toBeArrayOfWithLength, toBeAt, toBeBadGateway, toBeBadRequest, toBeConflict, toBeCreated, toBeExactlyAt, toBeForbidden, toBeInternalServerError, toBeNotFound, toBeOk, toBeOkWithItems, toBeQueriedWith, toBeRoutedTo, toBeUnauthorized, toBeValid, toFail, toFailMatcher, toFailMatcherWith, toFailWith, toHaveNoContent, toHaveStatus, toMatchArray, toMatchExactJson, toMatchException, toMatchJson, toMatchRoute, toMatchText, toPassMatcher, toPassMatcherWith, toResultWith };