@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/test/property/arbitraries/canister_methods/query_method_arb.ts

@@ -0,0 +1,141 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Named } from '../..';
+import { Test } from '../../test';
+import { CandidReturnType } from '../candid/candid_return_type_arb';
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { CorrespondingJSType } from '../candid/corresponding_js_type';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import {
+    BodyGenerator,
+    generateMethodImplementation,
+    isDefined,
+    QueryOrUpdateConstraints,
+    TestsGenerator
+} from '.';
+
+export type QueryMethod = {
+    imports: Set<string>;
+    globalDeclarations: string[];
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export function QueryMethodArb<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue,
+    ReturnTypeAgentArgumentValue extends CorrespondingJSType,
+    ReturnTypeAgentResponseValue
+>(
+    context: Context<QueryOrUpdateConstraints>,
+    generator: {
+        generateBody: BodyGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue,
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >;
+        generateTests: TestsGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue,
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >;
+    },
+    paramTypeArrayArb: fc.Arbitrary<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>[]
+    >,
+    returnTypeArb: fc.Arbitrary<
+        CandidValueAndMeta<
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >
+    >
+): fc.Arbitrary<QueryMethod> {
+    const constraints = context.constraints;
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            paramTypeArrayArb,
+            returnTypeArb
+        )
+        .map(([defaultFunctionName, paramTypes, returnType]): QueryMethod => {
+            const functionName = constraints.name ?? defaultFunctionName;
+
+            const imports = new Set([
+                'query',
+                ...paramTypes.flatMap((param) => [...param.src.imports]),
+                ...returnType.src.imports
+            ]);
+
+            const namedParams = paramTypes.map(
+                <T>(param: T, index: number): Named<T> => ({
+                    name: `param${index}`,
+                    value: param
+                })
+            );
+
+            const methodImplementation = generateMethodImplementation(
+                namedParams,
+                returnType,
+                generator.generateBody,
+                functionName
+            );
+
+            const candidTypeDeclarations = [
+                ...paramTypes.flatMap(
+                    (param) => param.src.variableAliasDeclarations
+                ),
+                ...returnType.src.variableAliasDeclarations
+            ].filter(isDefined);
+
+            const globalDeclarations = candidTypeDeclarations;
+
+            const sourceCode = generateSourceCode(
+                functionName,
+                paramTypes,
+                returnType,
+                methodImplementation
+            );
+
+            const tests = generator.generateTests(
+                functionName,
+                namedParams,
+                returnType
+            );
+
+            return {
+                imports,
+                globalDeclarations,
+                sourceCode,
+                tests
+            };
+        });
+}
+
+function generateSourceCode<
+    ParamType extends CorrespondingJSType,
+    ParamAgentType,
+    ReturnType extends CandidReturnType,
+    ReturnAgentType
+>(
+    functionName: string,
+    paramTypes: CandidValueAndMeta<ParamType, ParamAgentType>[],
+    returnType: CandidValueAndMeta<ReturnType, ReturnAgentType>,
+    methodImplementation: string
+): string {
+    const paramTypeObjects = paramTypes
+        .map((param) => param.src.typeObject)
+        .join(', ');
+
+    const returnTypeObject = returnType.src.typeObject;
+
+    const escapedFunctionName = functionName.startsWith('"')
+        ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+        : functionName;
+
+    return `@query([${paramTypeObjects}], ${returnTypeObject})\n${escapedFunctionName}${methodImplementation}`;
+}

package/src/experimental/test/property/arbitraries/canister_methods/update_method_arb.ts

@@ -0,0 +1,158 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Named } from '../..';
+import { Test } from '../../test';
+import { CandidReturnType } from '../candid/candid_return_type_arb';
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { CorrespondingJSType } from '../candid/corresponding_js_type';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import {
+    BodyGenerator,
+    generateMethodImplementation,
+    isDefined,
+    QueryOrUpdateConstraints,
+    TestsGenerator
+} from '.';
+
+export type UpdateMethod<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+> = {
+    imports: Set<string>;
+    globalDeclarations: string[];
+    sourceCode: string;
+    tests: Test[][];
+    paramTypes: CandidValueAndMeta<
+        ParamAgentArgumentValue,
+        ParamAgentResponseValue
+    >[];
+    methodName: string;
+};
+
+export function UpdateMethodArb<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue,
+    ReturnTypeAgentArgumentValue extends CorrespondingJSType,
+    ReturnTypeAgentResponseValue
+>(
+    context: Context<QueryOrUpdateConstraints>,
+    generator: {
+        generateBody: BodyGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue,
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >;
+        generateTests: TestsGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue,
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >;
+    },
+    paramTypeArrayArb: fc.Arbitrary<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>[]
+    >,
+    returnTypeArb: fc.Arbitrary<
+        CandidValueAndMeta<
+            ReturnTypeAgentArgumentValue,
+            ReturnTypeAgentResponseValue
+        >
+    >
+): fc.Arbitrary<
+    UpdateMethod<ParamAgentArgumentValue, ParamAgentResponseValue>
+> {
+    const constraints = context.constraints;
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            paramTypeArrayArb,
+            returnTypeArb
+        )
+        .map(
+            ([defaultFunctionName, paramTypes, returnType]): UpdateMethod<
+                ParamAgentArgumentValue,
+                ParamAgentResponseValue
+            > => {
+                const functionName = constraints.name ?? defaultFunctionName;
+
+                const imports = new Set([
+                    'update',
+                    ...paramTypes.flatMap((param) => [...param.src.imports]),
+                    ...returnType.src.imports
+                ]);
+
+                const namedParams = paramTypes.map(
+                    <T>(param: T, index: number): Named<T> => ({
+                        name: `param${index}`,
+                        value: param
+                    })
+                );
+
+                const methodImplementation = generateMethodImplementation(
+                    namedParams,
+                    returnType,
+                    generator.generateBody,
+                    functionName
+                );
+
+                const candidTypeDeclarations = [
+                    ...paramTypes.flatMap(
+                        (param) => param.src.variableAliasDeclarations
+                    ),
+                    ...returnType.src.variableAliasDeclarations
+                ].filter(isDefined);
+
+                const globalDeclarations = candidTypeDeclarations;
+
+                const sourceCode = generateSourceCode(
+                    functionName,
+                    paramTypes,
+                    returnType,
+                    methodImplementation
+                );
+
+                const tests = generator.generateTests(
+                    functionName,
+                    namedParams,
+                    returnType
+                );
+
+                return {
+                    imports,
+                    globalDeclarations,
+                    sourceCode,
+                    tests,
+                    paramTypes,
+                    methodName: functionName
+                };
+            }
+        );
+}
+
+function generateSourceCode<
+    ParamType extends CorrespondingJSType,
+    ParamAgentType,
+    ReturnType extends CandidReturnType,
+    ReturnAgentType
+>(
+    functionName: string,
+    paramTypes: CandidValueAndMeta<ParamType, ParamAgentType>[],
+    returnType: CandidValueAndMeta<ReturnType, ReturnAgentType>,
+    methodImplementation: string
+): string {
+    const paramTypeObjects = paramTypes
+        .map((param) => param.src.typeObject)
+        .join(', ');
+
+    const returnTypeObject = returnType.src.typeObject;
+
+    const escapedFunctionName = functionName.startsWith('"')
+        ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+        : functionName;
+
+    return `@update([${paramTypeObjects}], ${returnTypeObject})\n${escapedFunctionName}${methodImplementation}`;
+}

package/src/experimental/test/property/arbitraries/config.ts

@@ -0,0 +1,4 @@
+import '#experimental/build/assert_experimental';
+
+export const DEFAULT_DEFINITION_MAX_DEPTH = 5;
+export const DEFAULT_VALUE_MAX_DEPTH = 5;

package/src/experimental/test/property/arbitraries/http/body_arb.ts

@@ -0,0 +1,7 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+export function BodyArb(): fc.Arbitrary<Uint8Array> {
+    return fc.json().map((json) => new Uint8Array(Buffer.from(json, 'utf-8')));
+}

package/src/experimental/test/property/arbitraries/http/headers_arb.ts

@@ -0,0 +1,22 @@
+import '#experimental/build/assert_experimental';
+
+// See https://developers.cloudflare.com/rules/transform/request-header-modification/reference/header-format/
+import fc from 'fast-check';
+
+const RESERVED_HEADERS = ['__proto__'];
+
+export function HttpHeadersArb(): fc.Arbitrary<[string, string][]> {
+    const HeaderNameArb = fc
+        .stringMatching(/^[a-zA-Z0-9_-]+$/)
+        .filter((name) => !RESERVED_HEADERS.includes(name));
+
+    const HeaderValueArb = fc
+        .stringMatching(/^[a-zA-Z0-9_ .'!-+*#$&`|~^%]+$/)
+        .map((value) => value.trim());
+
+    const HeaderArb = fc.tuple(HeaderNameArb, HeaderValueArb);
+
+    return fc.uniqueArray(HeaderArb, {
+        selector: ([name, _]) => name.toLowerCase()
+    });
+}

package/src/experimental/test/property/arbitraries/http/request_arb.ts

@@ -0,0 +1,158 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { HttpRequest } from '#lib/canisters/http_gateway/idl/index';
+
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { blobToSrcLiteral } from '../candid/to_src_literal/blob';
+import { stringToSrcLiteral } from '../candid/to_src_literal/string';
+import { BodyArb } from './body_arb';
+import { HttpHeadersArb } from './headers_arb';
+
+type RequestMethod =
+    // | 'CONNECT' // Results in WARN hyper::proto::h1::role: unexpected content-length found, canceling
+    | 'DELETE'
+    | 'GET'
+    // | 'HEAD' // Results in the body getting dropped
+    | 'OPTIONS'
+    | 'PATCH'
+    | 'POST'
+    | 'PUT'
+    | 'TRACE';
+
+const RequestMethodArb = fc.constantFrom<RequestMethod>(
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE'
+    // TODO add back in when resolved https://github.com/demergent-labs/azle/issues/2404
+    // 'OPTIONS',
+    // 'TRACE',
+    // 'PATCH'
+);
+
+const UrlPathArb = fc.webUrl({ withQueryParameters: true }).map((url) => {
+    const parsedUrl = new URL(url);
+    // fc.webUrl gives us a path that is already encoded, but only partly. I
+    // have found it leaving $ and @ unencoded. So to be safe we have to decode
+    // all of the values (to prevent % from being encoded) and then reencode the
+    // values to encode symbols such as $ and @
+    const pathname = parsedUrl.pathname
+        .split('/')
+        .map((value) => encodeString(value))
+        .join('/');
+    const search = encodeString(parsedUrl.search, '?');
+    const hash = encodeString(parsedUrl.hash, '#');
+    return `${pathname}${search}${hash}`;
+});
+
+function encodeString(text: string, prefix: string = ''): string {
+    if (text.length === 0) {
+        return text;
+    }
+
+    return `${prefix}${encodeURIComponent(
+        decodeURIComponent(text.slice(prefix.length))
+    )}`;
+}
+
+// TODO make this function's return type explicit https://github.com/demergent-labs/azle/issues/1860
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function HttpRequestValueArb() {
+    return fc
+        .tuple(
+            RequestMethodArb,
+            UrlPathArb,
+            HttpHeadersArb(),
+            BodyArb(),
+            fc
+                .option(fc.integer({ min: 0, max: 2 ** 16 - 1 }))
+                .map((optCertVer): [number] | [] => {
+                    return optCertVer === null ? [] : [optCertVer];
+                })
+        )
+        .map(
+            ([
+                method,
+                url,
+                headers,
+                body,
+                certificate_version
+            ]): HttpRequest => {
+                return {
+                    method,
+                    url,
+                    headers,
+                    body,
+                    certificate_version
+                };
+            }
+        );
+}
+
+export function HttpRequestArb(): fc.Arbitrary<
+    CandidValueAndMeta<HttpRequest>
+> {
+    return HttpRequestValueArb().map((httpRequest) => {
+        const headerStrings = httpRequest.headers
+            .map(
+                ([name, value]) =>
+                    `[${stringToSrcLiteral(name)},${stringToSrcLiteral(value)}]`
+            )
+            .join(',');
+
+        const bodySrc = blobToSrcLiteral(new Uint8Array(httpRequest.body));
+
+        const certificateVersion =
+            'Some' in httpRequest.certificate_version
+                ? `[${httpRequest.certificate_version.Some}]`
+                : [];
+
+        return {
+            value: {
+                agentArgumentValue: httpRequest,
+                agentResponseValue: httpRequest,
+                runtimeTypeObject: HttpRequest
+            },
+            src: {
+                typeAnnotation: 'HttpRequest',
+                typeObject: 'HttpRequest',
+                variableAliasDeclarations: [
+                    generateVariableAliasDeclarations()
+                ],
+                imports: new Set(['IDL']),
+                valueLiteral: `{
+                    method: '${httpRequest.method}',
+                    url: '${httpRequest.url}',
+                    headers: [${headerStrings}],
+                    body: ${bodySrc},
+                    certificate_version: ${certificateVersion}
+                }`,
+                idl: 'HttpRequest'
+            }
+        };
+    });
+}
+
+function generateVariableAliasDeclarations(): string {
+    return /*TS*/ `
+        export const RequestHeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+        export type RequestHeaderField = [string, string];
+
+        export const HttpRequest = IDL.Record({
+            method: IDL.Text,
+            url: IDL.Text,
+            headers: IDL.Vec(RequestHeaderField),
+            body: IDL.Vec(IDL.Nat8),
+            certificate_version: IDL.Opt(IDL.Nat16)
+        });
+        export type HttpRequest = {
+            method: string;
+            url: string;
+            headers: RequestHeaderField[];
+            body: Uint8Array;
+            certificate_version: [number] | [];
+        };
+    `;
+}

package/src/experimental/test/property/arbitraries/http/response_arb.ts

@@ -0,0 +1,192 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { HttpResponse } from '#lib/canisters/http_gateway/idl/index';
+
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { CorrespondingJSType } from '../candid/corresponding_js_type';
+import { blobToSrcLiteral } from '../candid/to_src_literal/blob';
+import { stringToSrcLiteral } from '../candid/to_src_literal/string';
+import { BodyArb } from './body_arb';
+import { HttpHeadersArb } from './headers_arb';
+
+export type HttpResponseAgentResponseValue = {
+    status: number;
+    headers: [string, string][];
+    body: string;
+};
+
+// The following statuses are specified in the spec so we will favor these
+// status in out tests
+// https://www.rfc-editor.org/rfc/rfc9110.html
+const SPEC_SPECIFIED_STATUS = [
+    100, 101, 200, 201, 202, 203, 204, 205, 206, 300, 301, 302, 303, 304, 305,
+    306, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 409, 410, 411, 412,
+    413, 414, 415, 416, 417, 418, 421, 422, 426, 500, 501, 502, 503, 504, 505
+];
+
+const StatusCodeArb = fc
+    .oneof(
+        {
+            arbitrary: fc.constantFrom(
+                ...SPEC_SPECIFIED_STATUS.filter((value) => value >= 200) // The ic replica doesn't support returning status codes in the 1xx range.
+            ),
+            weight: 2
+        },
+        { arbitrary: fc.integer({ min: 200, max: 599 }), weight: 1 } // The ic replica doesn't support returning status codes in the 1xx range.
+    )
+    .filter((status) => status !== 407 && status !== 421 && status !== 206);
+// TODO Node's fetch doesn't handle 407 the same as other status, so we're filtering it out until we can figure out why
+// TODO https://github.com/demergent-labs/azle/pull/1652
+// TODO same applies to 421 status see https://github.com/demergent-labs/fourZeroSeven for more details
+// TODO https://github.com/nodejs/help/issues/4345
+// TODO Status 206 needs Content-Range header to work so we're filtering it out until we support that header in our arbitraries
+// TODO https://github.com/demergent-labs/azle/issues/2768
+
+export function HttpResponseValueArb(): fc.Arbitrary<HttpResponse> {
+    return fc
+        .tuple(StatusCodeArb, HttpHeadersArb())
+        .chain(([statusCode, headers]) => {
+            return fc.tuple(
+                fc.constant(statusCode),
+                fc.constant(headers),
+                hasBody(statusCode) ? BodyArb() : fc.constant(new Uint8Array())
+            );
+        })
+        .map(([status_code, headers, body]): HttpResponse => {
+            return {
+                status_code,
+                headers,
+                body,
+                upgrade: [],
+                streaming_strategy: []
+            };
+        });
+}
+export function HttpResponseArb(
+    token: CandidValueAndMeta<CorrespondingJSType>
+): fc.Arbitrary<
+    CandidValueAndMeta<HttpResponse, HttpResponseAgentResponseValue>
+> {
+    return HttpResponseValueArb().map((response) => {
+        const lowerCasedHeaders = response.headers.map<[string, string]>(
+            ([name, value]) => [name.toLowerCase(), value]
+        );
+
+        const agentResponseValue = {
+            status: response.status_code,
+            headers: lowerCasedHeaders,
+            body:
+                response.status_code === 204 // No Content
+                    ? ''
+                    : new TextDecoder().decode(new Uint8Array(response.body))
+        };
+
+        const headerStrings = response.headers
+            .map(
+                ([name, value]) =>
+                    `[${stringToSrcLiteral(name)},${stringToSrcLiteral(value)}]`
+            )
+            .join(',');
+
+        const bodySrc = blobToSrcLiteral(new Uint8Array(response.body));
+
+        const responseImports = ['IDL', 'Principal'];
+
+        return {
+            value: {
+                agentArgumentValue: response,
+                agentResponseValue: agentResponseValue,
+                runtimeTypeObject: HttpResponse
+            },
+            src: {
+                typeAnnotation: 'HttpResponse',
+                typeObject: 'HttpResponse',
+                variableAliasDeclarations: [
+                    ...token.src.variableAliasDeclarations,
+                    generateVariableAliasDeclarations(
+                        token.src.typeObject,
+                        token.src.typeAnnotation
+                    )
+                ],
+                imports: new Set([...responseImports, ...token.src.imports]),
+                valueLiteral: `{
+                status_code: ${response.status_code},
+                    headers: [${headerStrings}],
+                    body: ${bodySrc},
+                    upgrade: [],
+                    streaming_strategy: []
+                }`,
+                idl: 'HttpResponse'
+            }
+        };
+    });
+}
+
+function hasBody(statusCode: number): boolean {
+    // The following code must not have content according to the http spec
+    // https://www.rfc-editor.org/rfc/rfc9110.html
+    if (
+        statusCode < 200 ||
+        statusCode === 204 ||
+        statusCode === 205 ||
+        statusCode === 304
+    ) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+function generateVariableAliasDeclarations(
+    TokenIdl: string,
+    TokenType: string
+): string {
+    return /*TS*/ `
+        const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+        type HeaderField = [string, string];
+        const StreamingCallbackHttpResponse = IDL.Record({
+            body: IDL.Vec(IDL.Nat8),
+            token: IDL.Opt(${TokenIdl})
+        });
+        type StreamingCallbackHttpResponse = {
+            body: Uint8Array;
+            token: [${TokenType}] | [];
+        };
+        const Callback = IDL.Func(
+            [${TokenIdl}],
+            [IDL.Opt(StreamingCallbackHttpResponse)],
+            ['query']
+        );
+        type Callback = [Principal, string];
+        const CallbackStrategy = IDL.Record({
+            callback: Callback,
+            token: ${TokenIdl}
+        });
+        type CallbackStrategy = {
+            callback: Callback;
+            token: ${TokenType};
+        };
+        const StreamingStrategy = IDL.Variant({
+            Callback: CallbackStrategy
+        });
+        type StreamingStrategy = {
+            Callback: CallbackStrategy;
+        };
+        const HttpResponse = IDL.Record({
+            status_code: IDL.Nat16,
+            headers: IDL.Vec(HeaderField),
+            body: IDL.Vec(IDL.Nat8),
+            upgrade: IDL.Opt(IDL.Bool),
+            streaming_strategy: IDL.Opt(StreamingStrategy)
+        });
+        type HttpResponse = {
+            status_code: number;
+            headers: HeaderField[];
+            body: Uint8Array;
+            upgrade: [boolean] | [];
+            streaming_strategy: [StreamingStrategy] | [];
+        };
+    `;
+}