@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/test/property/arbitraries/candid/recursive/definition_arb.ts

@@ -0,0 +1,125 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { Context } from '../../types';
+import { UniqueIdentifierArb } from '../../unique_identifier_arb';
+import {
+    CandidDefinition,
+    DefinitionConstraints,
+    RecursiveCandidDefinition,
+    RecursiveCandidDefinitionMemo,
+    RecursiveCandidName,
+    WithShapes,
+    WithShapesArb
+} from '../candid_definition_arb/types';
+
+export function RecursiveDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArbForInnerType: RecursiveCandidDefinitionMemo,
+    parents: RecursiveCandidName[]
+): WithShapesArb<RecursiveCandidDefinition> {
+    return UniqueIdentifierArb('globalNames')
+        .chain((name): fc.Arbitrary<RecursiveCandidName> => {
+            const recCanDef: RecursiveCandidName = {
+                candidMeta: {
+                    candidType: 'Recursive',
+                    typeObject: name,
+                    typeAnnotation: name,
+                    imports: new Set(),
+                    variableAliasDeclarations: [],
+                    runtimeTypeObject: IDL.Rec()
+                },
+                name
+            };
+            return fc.constant(recCanDef);
+        })
+        .chain((innerRecDef) => {
+            return fc.tuple(
+                candidTypeArbForInnerType(
+                    {
+                        ...context,
+                        constraints: {
+                            recursiveWeights: true, // This should be true so that the below weights will be respected all the way down. Until those issues are resolved we can't have blobs, tuples or vecs anywhere in any recursive shapes
+                            weights: {
+                                blob: 0,
+                                tuple: 0,
+                                vec: 0
+                                // TODO there are a lot of bugs with recursion so we are disabling the problematic types until the issues are resolved
+                                // https://github.com/demergent-labs/azle/issues/1518
+                                // https://github.com/demergent-labs/azle/issues/1513
+                                // https://github.com/demergent-labs/azle/issues/1525
+                            },
+                            forceInline: true
+                        }
+                    },
+                    [innerRecDef, ...parents]
+                )(context.constraints.depthLevel ?? 0),
+                fc.constant(innerRecDef)
+            );
+        })
+        .map(
+            ([
+                { definition: innerType },
+                recCanDef
+            ]): WithShapes<RecursiveCandidDefinition> => {
+                const {
+                    name,
+                    candidMeta: { typeObject, typeAnnotation }
+                } = recCanDef;
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(name, innerType);
+
+                const imports = generateImports(innerType);
+
+                const runtimeTypeObject = generateRuntimeTypeObject(innerType);
+
+                const recursiveShape: RecursiveCandidDefinition = {
+                    candidMeta: {
+                        typeObject,
+                        typeAnnotation,
+                        variableAliasDeclarations,
+                        imports,
+                        candidType: 'Recursive',
+                        runtimeTypeObject
+                    },
+                    name,
+                    innerType
+                };
+
+                return {
+                    definition: recursiveShape,
+                    recursiveShapes: {
+                        [name]: recursiveShape
+                    }
+                };
+            }
+        );
+}
+
+function generateVariableAliasDeclarations(
+    name: string,
+    innerType: CandidDefinition
+): string[] {
+    return [
+        ...innerType.candidMeta.variableAliasDeclarations,
+        `const ${name} = IDL.Rec()`,
+        `${name}.fill(${innerType.candidMeta.typeObject})`,
+        `type ${name} = ${innerType.candidMeta.typeAnnotation};`
+    ];
+}
+
+function generateImports(innerType: CandidDefinition): Set<string> {
+    return new Set([...innerType.candidMeta.imports, 'IDL']);
+}
+
+function generateRuntimeTypeObject(innerType: CandidDefinition): IDL.Type {
+    const rec = IDL.Rec();
+
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    rec.fill(innerType.candidMeta.runtimeTypeObject ?? IDL.Empty);
+
+    return rec;
+}

package/src/experimental/test/property/arbitraries/candid/recursive/index.ts

@@ -0,0 +1,35 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_DEFINITION_MAX_DEPTH } from '../../config';
+import { Context } from '../../types';
+import { complexCandidDefinitionMemo } from '../candid_definition_arb/complex_candid_definition_memo';
+import { RecursiveCandidDefinition } from '../candid_definition_arb/types';
+import { CandidValueAndMeta } from '../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../candid_value_and_meta_arb_generator';
+import { RecursiveDefinitionArb } from './definition_arb';
+import { RecursiveValuesArb } from './values_arb';
+
+export type Recursive = any;
+export type RecursiveShapes = { [key: string]: RecursiveCandidDefinition };
+
+export function RecursiveArb(
+    context: Context
+): fc.Arbitrary<CandidValueAndMeta<Recursive>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        RecursiveDefinitionArb(
+            {
+                ...context,
+                constraints: {
+                    depthLevel: DEFAULT_DEFINITION_MAX_DEPTH,
+                    forceInline: true
+                }
+            },
+            complexCandidDefinitionMemo,
+            []
+        ),
+        RecursiveValuesArb
+    );
+}

package/src/experimental/test/property/arbitraries/candid/recursive/values_arb.ts

@@ -0,0 +1,43 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../config';
+import { Context } from '../../types';
+import {
+    RecursiveCandidDefinition,
+    RecursiveCandidName
+} from '../candid_definition_arb/types';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../candid_values_arb';
+import { Recursive, RecursiveShapes } from '.';
+
+export function RecursiveNameValuesArb(
+    context: Context<CandidValueConstraints>,
+    recDefinition: RecursiveCandidName | RecursiveCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Recursive>> {
+    const recShape = recursiveShapes[recDefinition.name];
+    return RecursiveValuesArb(context, recShape, recursiveShapes);
+}
+
+export function RecursiveValuesArb(
+    context: Context<CandidValueConstraints>,
+    recDefinition: RecursiveCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Recursive>> {
+    const constraints = context.constraints ?? {
+        depthLevel: DEFAULT_VALUE_MAX_DEPTH
+    };
+    return CandidValueArb(
+        {
+            ...context,
+            constraints
+        },
+        recDefinition.innerType,
+        recursiveShapes
+    );
+}

package/src/experimental/test/property/arbitraries/candid/reference/func_arb/definition_arb.ts

@@ -0,0 +1,198 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { toFuncArgs } from '#lib/func';
+import { IDL } from '#lib/index';
+
+import { UniqueIdentifierArb } from '../../../unique_identifier_arb';
+import {
+    CandidDefinition,
+    FuncCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { VoidDefinitionArb } from '../../primitive/void_arb';
+
+type Mode = 'query' | 'update' | 'oneway';
+
+export function FuncDefinitionArb(
+    candidDefArb: WithShapesArb<CandidDefinition>
+): WithShapesArb<FuncCandidDefinition> {
+    return fc
+        .constantFrom<Mode>('query', 'update', 'oneway')
+        .chain((mode) => {
+            const returnType =
+                mode === 'oneway' ? VoidDefinitionArb() : candidDefArb;
+
+            return fc.tuple(
+                UniqueIdentifierArb('globalNames'),
+                fc.array(candidDefArb),
+                returnType,
+                fc.constant(mode),
+                fc.boolean()
+            );
+        })
+        .map(
+            ([
+                name,
+                paramsAndShapes,
+                returnFuncAndShapes,
+                mode,
+                useTypeDeclaration
+            ]): WithShapes<FuncCandidDefinition> => {
+                const params = paramsAndShapes.map(
+                    (paramAndShapes) => paramAndShapes.definition
+                );
+                const returnFunc = returnFuncAndShapes.definition;
+                const recursiveShapes = paramsAndShapes.reduce(
+                    (acc, paramAndShapes) => {
+                        return { ...acc, ...paramAndShapes.recursiveShapes };
+                    },
+                    returnFuncAndShapes.recursiveShapes
+                );
+                const typeAnnotation = generateCandidTypeAnnotation(
+                    useTypeDeclaration,
+                    name
+                );
+
+                const typeObject = generateTypeObject(
+                    useTypeDeclaration,
+                    name,
+                    params,
+                    returnFunc,
+                    mode
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(
+                    params,
+                    returnFunc,
+                    mode
+                );
+
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        useTypeDeclaration,
+                        name,
+                        params,
+                        returnFunc,
+                        mode
+                    );
+
+                const imports = generateImports(params, returnFunc);
+
+                return {
+                    definition: {
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            runtimeTypeObject,
+                            variableAliasDeclarations,
+                            imports,
+                            candidType: 'Func'
+                        },
+                        paramCandidMeta: params,
+                        returnCandidMeta: returnFunc
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function generateImports(
+    params: CandidDefinition[],
+    returnFunc: CandidDefinition
+): Set<string> {
+    return new Set([
+        ...params.flatMap((param) => [...param.candidMeta.imports]),
+        ...returnFunc.candidMeta.imports,
+        'IDL',
+        'Principal'
+    ]);
+}
+
+function generateVariableAliasDeclarations(
+    useTypeDeclaration: boolean,
+    name: string,
+    paramCandids: CandidDefinition[],
+    returnCandid: CandidDefinition,
+    mode: Mode
+): string[] {
+    const paramTypeDeclarations = paramCandids.flatMap(
+        (param) => param.candidMeta.variableAliasDeclarations
+    );
+    const returnTypeDeclaration =
+        returnCandid.candidMeta.variableAliasDeclarations;
+
+    if (useTypeDeclaration === true) {
+        const type = [
+            `type ${name} = ${generateCandidTypeAnnotation(false, name)};`
+        ];
+        return [
+            ...paramTypeDeclarations,
+            ...returnTypeDeclaration,
+            `const ${name} = ${generateTypeObject(
+                false,
+                name,
+                paramCandids,
+                returnCandid,
+                mode
+            )}`,
+            ...type
+        ];
+    }
+
+    return [...paramTypeDeclarations, ...returnTypeDeclaration];
+}
+
+function generateCandidTypeAnnotation(
+    useTypeDeclaration: boolean,
+    name: string
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return `[Principal, string]`;
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    paramCandids: CandidDefinition[],
+    returnCandid: CandidDefinition,
+    mode: Mode
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    const params = paramCandids
+        .map((param) => param.candidMeta.typeObject)
+        .join(', ');
+
+    const returnType = returnCandid.candidMeta.typeObject;
+
+    return `IDL.Func([${params}], [${returnType}], ${
+        mode === 'update' ? '' : `['${mode}']`
+    })`;
+}
+
+function generateRuntimeTypeObject(
+    paramCandids: CandidDefinition[],
+    returnCandid: CandidDefinition,
+    mode: Mode
+): IDL.Type {
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    const params = paramCandids.map(
+        (param) => param.candidMeta.runtimeTypeObject ?? IDL.Empty
+    );
+
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    return IDL.Func(
+        toFuncArgs(params),
+        [returnCandid.candidMeta.runtimeTypeObject ?? IDL.Empty],
+        [mode]
+    );
+}

package/src/experimental/test/property/arbitraries/candid/reference/func_arb/index.ts

@@ -0,0 +1,23 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+import fc from 'fast-check';
+
+import { Context } from '../../../types';
+import { candidDefinitionArb } from '../../candid_definition_arb';
+import { CandidValueAndMeta } from '../../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../../candid_value_and_meta_arb_generator';
+import { FuncDefinitionArb } from './definition_arb';
+import { FuncValueArb } from './values_arb';
+
+export type Func = [Principal, string];
+
+export function FuncArb(
+    context: Context
+): fc.Arbitrary<CandidValueAndMeta<Func>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        FuncDefinitionArb(candidDefinitionArb(context, {})),
+        FuncValueArb
+    );
+}

package/src/experimental/test/property/arbitraries/candid/reference/func_arb/values_arb.ts

@@ -0,0 +1,70 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+import fc from 'fast-check';
+
+import { JsPropertyNameArb } from '../../../js_name_arb';
+import { CandidValues } from '../../candid_values_arb';
+import { PrincipalValueArb } from '../principal_arb';
+import { Func } from '.';
+
+/**
+ * Generates arbitrary Candid function values for property-based testing.
+ * Creates a tuple of principal and function name, then maps it to the required format.
+ *
+ * @returns An arbitrary that generates CandidValues<Func>
+ */
+export function FuncValueArb(): fc.Arbitrary<CandidValues<Func>> {
+    return fc
+        .tuple(PrincipalValueArb(), JsPropertyNameArb)
+        .map(([principal, propertyName]) =>
+            generateCandidFuncValue(principal, propertyName)
+        );
+}
+
+function generateCandidFuncValue(
+    principal: CandidValues<Principal>,
+    propertyName: string
+): CandidValues<Func> {
+    const functionName = extractFunctionName(propertyName);
+
+    const value: Func = [principal.agentArgumentValue, functionName];
+
+    return {
+        valueLiteral: generateValueLiteral(principal, functionName),
+        agentArgumentValue: value,
+        agentResponseValue: value
+    };
+}
+
+/**
+ * Extracts the function name from a potentially quoted property name
+ *
+ * @param propertyName - The raw property name which may be quoted
+ * @returns The cleaned function name
+ *
+ * @remarks
+ * If the given property name has any special characters, or is otherwise not a
+ * valid identifier, it will be quoted to make it valid. And therefore must be
+ * unquoted when used as a function name.
+ */
+function extractFunctionName(propertyName: string): string {
+    return propertyName.startsWith('"')
+        ? propertyName.slice(1, -1)
+        : propertyName;
+}
+
+function generateValueLiteral(
+    principal: CandidValues<Principal>,
+    functionName: string
+): string {
+    const functionNameLiteral = `"${escapeStringLiteral(functionName)}"`;
+
+    return `[${principal.valueLiteral}, ${functionNameLiteral}]`;
+}
+
+function escapeStringLiteral(input: string): string {
+    return input
+        .replace(/\\/g, '\\\\') // Escape backslashes
+        .replace(/"/g, '\\"'); // Escape double quotes
+}

package/src/experimental/test/property/arbitraries/candid/reference/principal_arb.ts

@@ -0,0 +1,43 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+import fc from 'fast-check';
+
+import { Context } from '../../types';
+import {
+    PrincipalCandidDefinition,
+    WithShapesArb
+} from '../candid_definition_arb/types';
+import { CandidValueAndMeta } from '../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../candid_value_and_meta_arb_generator';
+import { CandidValues } from '../candid_values_arb';
+import { SimpleCandidDefinitionArb } from '../simple_type_arbs/definition_arb';
+import { SimpleCandidValuesArb } from '../simple_type_arbs/values_arb';
+import { principalToSrcLiteral } from '../to_src_literal/principal';
+
+export function PrincipalArb(
+    context: Context
+): fc.Arbitrary<CandidValueAndMeta<Principal>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        PrincipalDefinitionArb(),
+        PrincipalValueArb
+    );
+}
+
+export function PrincipalDefinitionArb(): WithShapesArb<PrincipalCandidDefinition> {
+    return SimpleCandidDefinitionArb('Principal');
+}
+
+export function PrincipalValueArb(): fc.Arbitrary<CandidValues<Principal>> {
+    return SimpleCandidValuesArb(principal(), principalToSrcLiteral);
+}
+
+function principal(): fc.Arbitrary<Principal> {
+    return fc
+        .uint8Array({
+            minLength: 0,
+            maxLength: 29
+        })
+        .map((sample) => Principal.fromUint8Array(sample));
+}