@ohos-ports/azle 0.33.0-beta.0

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

@@ -0,0 +1,195 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { Test } from '../test';
+import { CliStringVisitor } from '../visitors/cli-string-visitor';
+import { CorrespondingJSType } from './candid/corresponding_js_type';
+import { InitMethod } from './canister_methods/init_method_arb';
+import { InspectMessageMethod } from './canister_methods/inspect_message_method_arb';
+import { PostUpgradeMethod } from './canister_methods/post_upgrade_method_arb';
+import { PreUpgradeMethod } from './canister_methods/pre_upgrade_method_arb';
+import { QueryMethod } from './canister_methods/query_method_arb';
+import { UpdateMethod } from './canister_methods/update_method_arb';
+import { Context } from './types';
+
+export type Canister = {
+    initArgs: string[] | undefined;
+    postUpgradeArgs: string[] | undefined;
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export type CanisterMethod<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+> =
+    | QueryMethod
+    | UpdateMethod<ParamAgentArgumentValue, ParamAgentResponseValue>
+    | InitMethod<ParamAgentArgumentValue, ParamAgentResponseValue>
+    | PostUpgradeMethod<ParamAgentArgumentValue, ParamAgentResponseValue>
+    | PreUpgradeMethod
+    | InspectMessageMethod;
+
+export type CanisterConfig<
+    ParamAgentArgumentValue extends CorrespondingJSType = undefined,
+    ParamAgentResponseValue = undefined
+> = {
+    globalDeclarations?: string[];
+    initMethod?: InitMethod<ParamAgentArgumentValue, ParamAgentResponseValue>;
+    inspectMessageMethod?: InspectMessageMethod;
+    postUpgradeMethod?: PostUpgradeMethod<
+        ParamAgentArgumentValue,
+        ParamAgentResponseValue
+    >;
+    preUpgradeMethod?: PreUpgradeMethod;
+    queryMethods?: QueryMethod[];
+    updateMethods?: UpdateMethod<
+        ParamAgentArgumentValue,
+        ParamAgentResponseValue
+    >[];
+};
+
+// TODO: Update the signature to support init, pre/post upgrade, heartbeat, etc.
+export function CanisterArb<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+>(
+    context: Context,
+    configArb: fc.Arbitrary<
+        CanisterConfig<ParamAgentArgumentValue, ParamAgentResponseValue>
+    >
+): fc.Arbitrary<Canister> {
+    return configArb.map((config): Canister => {
+        const canisterMethods: CanisterMethod<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue
+        >[] = [
+            ...(config.initMethod ? [config.initMethod] : []),
+            ...(config.inspectMessageMethod
+                ? [config.inspectMessageMethod]
+                : []),
+            ...(config.postUpgradeMethod ? [config.postUpgradeMethod] : []),
+            ...(config.preUpgradeMethod ? [config.preUpgradeMethod] : []),
+            ...(config.queryMethods ?? []),
+            ...(config.updateMethods ?? [])
+        ];
+
+        const initArgs = config.initMethod?.params.map((param) => {
+            const value = param.value.value;
+            // TODO IDL.Empty is a placeholder for void...not quite correct
+            return (value.runtimeTypeObject ?? IDL.Empty).accept(
+                new CliStringVisitor(),
+                {
+                    value: value.agentArgumentValue
+                }
+            );
+        });
+
+        const postUpgradeArgs = config.postUpgradeMethod?.params.map(
+            (param) => {
+                const value = param.value.value;
+                // TODO IDL.Empty is a placeholder for void...not quite correct
+                return (value.runtimeTypeObject ?? IDL.Empty).accept(
+                    new CliStringVisitor(),
+                    {
+                        value: value.agentArgumentValue
+                    }
+                );
+            }
+        );
+
+        const sourceCode = generateSourceCode(
+            config.globalDeclarations ?? [],
+            canisterMethods,
+            context.inspectMessageImportHack
+        );
+
+        const tests = canisterMethods.reduce(
+            (acc: Test[][], canisterMethod): Test[][] => {
+                if (canisterMethod.tests.length < acc.length) {
+                    return acc.map((accTests, index) => {
+                        return [
+                            ...accTests,
+                            ...(canisterMethod.tests[index] ?? [])
+                        ];
+                    });
+                } else {
+                    return canisterMethod.tests.map(
+                        (canisterMethodTests, index) => {
+                            return [
+                                ...(acc[index] ?? []),
+                                ...canisterMethodTests
+                            ];
+                        }
+                    );
+                }
+            },
+            []
+        );
+
+        return {
+            initArgs,
+            postUpgradeArgs,
+            sourceCode,
+            tests
+        };
+    });
+}
+
+function generateSourceCode<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+>(
+    globalDeclarations: string[],
+    canisterMethods: CanisterMethod<
+        ParamAgentArgumentValue,
+        ParamAgentResponseValue
+    >[],
+    inspectMessageImportHack?: boolean
+): string {
+    const imports = [
+        ...new Set([
+            ...canisterMethods.flatMap((method) => [...method.imports])
+        ])
+    ]
+        .sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }))
+        .join();
+    const importLocation = `azle`;
+
+    const declarationsFromCanisterMethods = canisterMethods.flatMap(
+        (method) => {
+            if ('globalDeclarations' in method) {
+                return method.globalDeclarations;
+            }
+            return [];
+        }
+    );
+
+    const declarations = [
+        ...new Set([...globalDeclarations, ...declarationsFromCanisterMethods])
+    ].join('\n');
+
+    const sourceCodes = canisterMethods.map((method) => method.sourceCode);
+
+    const canister = `
+        export default class {
+            ${sourceCodes.join('\n    ')}
+        };
+    `;
+
+    return /*TS*/ `
+        ${inspectMessageImportHack === true ? `import { msgCaller, msgMethodName } from 'azle'; import { ic } from 'azle/experimental';` : ''}
+        import { ${imports} } from '${importLocation}';
+        // @ts-ignore
+        import { candidDeepEqual } from 'azle/_internal/test/candid_deep_equal';
+
+        // #region Declarations
+        ${declarations}
+        // #endregion Declarations
+
+        ${canister}
+    `;
+}

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

@@ -0,0 +1,79 @@
+import '#experimental/build/assert_experimental';
+
+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';
+
+export type BodyGenerator<
+    ParamAgentArgumentValue extends CorrespondingJSType = undefined,
+    ParamAgentResponseValue = undefined,
+    ReturnTypeAgentArgumentValue extends CorrespondingJSType = undefined,
+    ReturnTypeAgentResponseValue = undefined
+> = (
+    namedParams: Named<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>
+    >[],
+    returnType: CandidValueAndMeta<
+        ReturnTypeAgentArgumentValue,
+        ReturnTypeAgentResponseValue
+    >,
+    methodName: string
+) => string;
+
+export type TestsGenerator<
+    ParamAgentArgumentValue extends CorrespondingJSType = undefined,
+    ParamAgentResponseValue = undefined,
+    ReturnTypeAgentArgumentValue extends CorrespondingJSType = undefined,
+    ReturnTypeAgentResponseValue = undefined
+> = (
+    methodName: string,
+    namedParams: Named<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>
+    >[],
+    returnType: CandidValueAndMeta<
+        ReturnTypeAgentArgumentValue,
+        ReturnTypeAgentResponseValue
+    >
+) => Test[][];
+
+export type QueryOrUpdateConstraints = {
+    name?: string;
+};
+
+export function isDefined<T>(value: T | undefined): value is T {
+    return value !== undefined;
+}
+
+export function generateMethodImplementation<
+    ParamType extends CorrespondingJSType,
+    ParamAgentType,
+    ReturnType extends CandidReturnType,
+    ReturnAgentType
+>(
+    namedParams: Named<CandidValueAndMeta<ParamType, ParamAgentType>>[],
+    returnType: CandidValueAndMeta<ReturnType, ReturnAgentType>,
+    generateBody: BodyGenerator<
+        ParamType,
+        ParamAgentType,
+        ReturnType,
+        ReturnAgentType
+    >,
+    functionName: string,
+    inspectMessage?: boolean
+): string {
+    const paramNames = namedParams
+        .map((namedParam) => {
+            return `${namedParam.name}: ${namedParam.value.src.typeAnnotation}`;
+        })
+        .join(', ');
+
+    const body = generateBody(namedParams, returnType, functionName);
+
+    if (inspectMessage === true) {
+        return `(methodName: string, ...args: any[]): ${returnType.src.typeAnnotation} {${body}}`;
+    }
+
+    return `(${paramNames}): ${returnType.src.typeAnnotation} {${body}}`;
+}

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

@@ -0,0 +1,127 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Named } from '../..';
+import { Test } from '../../test';
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { CorrespondingJSType } from '../candid/corresponding_js_type';
+import { VoidArb } from '../candid/primitive/void_arb';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import {
+    BodyGenerator,
+    generateMethodImplementation,
+    isDefined,
+    TestsGenerator
+} from '.';
+
+export type InitMethod<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+> = {
+    imports: Set<string>;
+    globalDeclarations: string[];
+    params: Named<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>
+    >[];
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export function InitMethodArb<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+>(
+    context: Context,
+    generator: {
+        generateBody: BodyGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue
+        >;
+        generateTests: TestsGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue
+        >;
+    },
+    paramTypeArrayArb: fc.Arbitrary<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>[]
+    >
+): fc.Arbitrary<InitMethod<ParamAgentArgumentValue, ParamAgentResponseValue>> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            paramTypeArrayArb,
+            VoidArb({ ...context, constraints: {} })
+        )
+        .map(
+            ([functionName, paramTypes, returnType]): InitMethod<
+                ParamAgentArgumentValue,
+                ParamAgentResponseValue
+            > => {
+                const imports = new Set([
+                    'init',
+                    ...paramTypes.flatMap((param) => [...param.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 variableAliasDeclarations = paramTypes
+                    .flatMap((param) => param.src.variableAliasDeclarations)
+                    .filter(isDefined);
+
+                const globalDeclarations = variableAliasDeclarations;
+
+                const sourceCode = generateSourceCode(
+                    functionName,
+                    paramTypes,
+                    methodImplementation
+                );
+
+                const tests = generator.generateTests(
+                    functionName,
+                    namedParams,
+                    returnType
+                );
+
+                return {
+                    imports,
+                    globalDeclarations,
+                    params: namedParams,
+                    sourceCode,
+                    tests
+                };
+            }
+        );
+}
+
+function generateSourceCode<
+    ParamType extends CorrespondingJSType,
+    ParamAgentType
+>(
+    functionName: string,
+    paramTypes: CandidValueAndMeta<ParamType, ParamAgentType>[],
+    methodImplementation: string
+): string {
+    const paramTypeObjects = paramTypes
+        .map((param) => param.src.typeObject)
+        .join(', ');
+
+    const escapedFunctionName = functionName.startsWith('"')
+        ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+        : functionName;
+
+    return `@init([${paramTypeObjects}])\n${escapedFunctionName}${methodImplementation}`;
+}

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

@@ -0,0 +1,55 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Test } from '../../test';
+import { BoolArb } from '../candid/primitive/bool_arb';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import { BodyGenerator, generateMethodImplementation, TestsGenerator } from '.';
+
+export type InspectMessageMethod = {
+    imports: Set<string>;
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export function InspectMessageMethodArb(
+    context: Context,
+    generator: {
+        generateBody: BodyGenerator;
+        generateTests: TestsGenerator;
+    }
+): fc.Arbitrary<InspectMessageMethod> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            BoolArb({ ...context, constraints: {} }),
+            UniqueIdentifierArb('globalNames')
+        )
+        .map(([functionName, returnType]): InspectMessageMethod => {
+            const imports = new Set(['inspectMessage']);
+
+            const methodImplementation = generateMethodImplementation(
+                [],
+                returnType,
+                generator.generateBody,
+                functionName,
+                true
+            );
+
+            const escapedFunctionName = functionName.startsWith('"')
+                ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : functionName;
+
+            const sourceCode = `@inspectMessage\n${escapedFunctionName}${methodImplementation}`;
+
+            const tests = generator.generateTests(functionName, [], returnType);
+
+            return {
+                imports,
+                sourceCode,
+                tests
+            };
+        });
+}

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

@@ -0,0 +1,133 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Named } from '../..';
+import { Test } from '../../test';
+import { CandidValueAndMeta } from '../candid/candid_value_and_meta_arb';
+import { CorrespondingJSType } from '../candid/corresponding_js_type';
+import { VoidArb } from '../candid/primitive/void_arb';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import {
+    BodyGenerator,
+    generateMethodImplementation,
+    isDefined,
+    TestsGenerator
+} from '.';
+
+export type PostUpgradeMethod<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+> = {
+    imports: Set<string>;
+    globalDeclarations: string[];
+    params: Named<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>
+    >[];
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export function PostUpgradeMethodArb<
+    ParamAgentArgumentValue extends CorrespondingJSType,
+    ParamAgentResponseValue
+>(
+    context: Context,
+    generator: {
+        generateBody: BodyGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue
+        >;
+        generateTests: TestsGenerator<
+            ParamAgentArgumentValue,
+            ParamAgentResponseValue
+        >;
+    },
+    paramTypeArrayArb: fc.Arbitrary<
+        CandidValueAndMeta<ParamAgentArgumentValue, ParamAgentResponseValue>[]
+    >
+): fc.Arbitrary<
+    PostUpgradeMethod<ParamAgentArgumentValue, ParamAgentResponseValue>
+> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            paramTypeArrayArb,
+            VoidArb({ ...context, constraints: {} }),
+            UniqueIdentifierArb('globalNames')
+            // TODO: This unique id would be better named globalScope or something
+            // But needs to match the same scope as typeDeclarations so I'm using
+            // that for now.
+        )
+        .map(
+            ([functionName, paramTypes, returnType]): PostUpgradeMethod<
+                ParamAgentArgumentValue,
+                ParamAgentResponseValue
+            > => {
+                const imports = new Set([
+                    'postUpgrade',
+                    ...paramTypes.flatMap((param) => [...param.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 variableAliasDeclarations = paramTypes
+                    .flatMap((param) => param.src.variableAliasDeclarations)
+                    .filter(isDefined);
+
+                const globalDeclarations = variableAliasDeclarations;
+
+                const sourceCode = generateSourceCode(
+                    functionName,
+                    paramTypes,
+                    methodImplementation
+                );
+
+                const tests = generator.generateTests(
+                    functionName,
+                    namedParams,
+                    returnType
+                );
+
+                return {
+                    imports,
+                    globalDeclarations,
+                    params: namedParams,
+                    sourceCode,
+                    tests
+                };
+            }
+        );
+}
+
+function generateSourceCode<
+    ParamType extends CorrespondingJSType,
+    ParamAgentType
+>(
+    functionName: string,
+    paramTypes: CandidValueAndMeta<ParamType, ParamAgentType>[],
+    methodImplementation: string
+): string {
+    const paramTypeObjects = paramTypes
+        .map((param) => param.src.typeObject)
+        .join(', ');
+
+    const escapedFunctionName = functionName.startsWith('"')
+        ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+        : functionName;
+
+    return `@postUpgrade([${paramTypeObjects}])\n${escapedFunctionName}${methodImplementation}`;
+}

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

@@ -0,0 +1,57 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Test } from '../../test';
+import { VoidArb } from '../candid/primitive/void_arb';
+import { Context } from '../types';
+import { UniqueIdentifierArb } from '../unique_identifier_arb';
+import { BodyGenerator, generateMethodImplementation, TestsGenerator } from '.';
+
+export type PreUpgradeMethod = {
+    imports: Set<string>;
+    sourceCode: string;
+    tests: Test[][];
+};
+
+export function PreUpgradeMethodArb(
+    context: Context,
+    generator: {
+        generateBody: BodyGenerator;
+        generateTests: TestsGenerator;
+    }
+): fc.Arbitrary<PreUpgradeMethod> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('canisterProperties', 'property'),
+            VoidArb({ ...context, constraints: {} }),
+            UniqueIdentifierArb('globalNames')
+            // TODO: This unique id would be better named globalScope or something
+            // But needs to match the same scope as typeDeclarations so I'm using
+            // that for now.
+        )
+        .map(([functionName, returnType]): PreUpgradeMethod => {
+            const imports = new Set(['preUpgrade']);
+
+            const methodImplementation = generateMethodImplementation(
+                [],
+                returnType,
+                generator.generateBody,
+                functionName
+            );
+
+            const escapedFunctionName = functionName.startsWith('"')
+                ? `"${functionName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : functionName;
+
+            const sourceCode = `@preUpgrade\n${escapedFunctionName}${methodImplementation}`;
+
+            const tests = generator.generateTests(functionName, [], returnType);
+
+            return {
+                imports,
+                sourceCode,
+                tests
+            };
+        });
+}