@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/test/property/arbitraries/candid/constructed/record_arb/index.ts

@@ -0,0 +1,34 @@
+import '#experimental/build/assert_experimental';
+
+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 { CandidValueConstraints } from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecordDefinitionArb } from './definition_arb';
+import { RecordValuesArb } from './values_arb';
+
+export type Record =
+    | {
+          [x: string]: CorrespondingJSType;
+      }
+    | object;
+
+export function RecordArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<Record>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        RecordDefinitionArb(
+            {
+                ...context,
+                constraints: { maxLength: context.constraints.maxLength }
+            },
+            candidDefinitionArb(context, {})
+        ),
+        RecordValuesArb
+    );
+}

package/src/experimental/test/property/arbitraries/candid/constructed/record_arb/values_arb.ts

@@ -0,0 +1,95 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import { RecordCandidDefinition } from '../../candid_definition_arb/types';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecursiveShapes } from '../../recursive';
+import { Record } from './index';
+
+type Field = [string, CandidValues<CorrespondingJSType>];
+type ArbField = [string, fc.Arbitrary<CandidValues<CorrespondingJSType>>];
+
+export function RecordValuesArb(
+    context: Context<CandidValueConstraints>,
+    recordDefinition: RecordCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Record>> {
+    const depthLevel =
+        context.constraints?.depthLevel ?? DEFAULT_VALUE_MAX_DEPTH;
+    const fieldValues = recordDefinition.innerTypes.map(([name, innerType]) => {
+        const result: ArbField = [
+            name,
+            CandidValueArb(
+                {
+                    ...context,
+                    constraints: {
+                        ...context.constraints,
+                        depthLevel: depthLevel - 1
+                    }
+                },
+                innerType,
+                recursiveShapes
+            )
+        ];
+        return result;
+    });
+    const arbitraryFieldValues = fieldValues.map(([key, arbValue]) =>
+        arbValue.map((value): Field => [key, value])
+    );
+
+    return fc.tuple(...arbitraryFieldValues).map((fieldValues) => {
+        const valueLiteral = generateValueLiteral(fieldValues);
+        const agentArgumentValue = generateValue(fieldValues);
+        const agentResponseValue = generateValue(fieldValues, true);
+
+        return {
+            valueLiteral,
+            agentArgumentValue,
+            agentResponseValue
+        };
+    });
+}
+
+function generateValue(fields: Field[], returned: boolean = false): Record {
+    return fields.length === 0
+        ? {}
+        : fields.reduce((record, [fieldName, fieldCandidValues]) => {
+              const normalizedFieldName =
+                  fieldName.startsWith('"') && fieldName.endsWith('"')
+                      ? fieldName.slice(1, -1)
+                      : fieldName;
+              return {
+                  ...record,
+                  [normalizedFieldName]: returned
+                      ? fieldCandidValues.agentResponseValue
+                      : fieldCandidValues.agentArgumentValue
+              };
+          }, {});
+}
+
+function generateValueLiteral(fields: Field[]): string {
+    if (fields.length === 0) {
+        return '{}';
+    }
+
+    const fieldLiterals = fields
+        .map(([fieldName, fieldCandidValues]) => {
+            const escapedFieldName = fieldName.startsWith('"')
+                ? `"${fieldName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : fieldName;
+            return `${escapedFieldName}: ${fieldCandidValues.valueLiteral}`;
+        })
+        .join(',\n');
+
+    return `{
+        ${fieldLiterals}
+    }`;
+}

package/src/experimental/test/property/arbitraries/candid/constructed/tuple_arb/definition_arb.ts

@@ -0,0 +1,159 @@
+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,
+    TupleCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { RecursiveShapes } from '../../recursive';
+
+export function TupleDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArbForFields: WithShapesArb<CandidDefinition>
+): WithShapesArb<TupleCandidDefinition> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            fc.array(candidTypeArbForFields, {
+                minLength: 1,
+                maxLength: context.constraints.maxLength
+            }),
+            // Although no minLength is technically required (according to the
+            // spec), there are some issues with vecs of empty objects that are causing some problems
+            // https://github.com/demergent-labs/azle/issues/1453
+            fc.boolean()
+        )
+        .map(
+            ([
+                name,
+                fieldsAndShapes,
+                useTypeDeclaration
+            ]): WithShapes<TupleCandidDefinition> => {
+                const fields = fieldsAndShapes.map(
+                    (field): CandidDefinition => field.definition
+                );
+                const recursiveShapes = fieldsAndShapes.reduce(
+                    (acc, field): RecursiveShapes => {
+                        return { ...acc, ...field.recursiveShapes };
+                    },
+                    {}
+                );
+                const typeAnnotation = generateCandidTypeAnnotation(
+                    useTypeDeclaration,
+                    name,
+                    fields
+                );
+
+                const typeObject = generateTypeObject(
+                    useTypeDeclaration,
+                    name,
+                    fields
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(fields);
+
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        useTypeDeclaration,
+                        name,
+                        fields
+                    );
+
+                const imports = generateImports(fields);
+
+                return {
+                    definition: {
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            runtimeTypeObject,
+                            variableAliasDeclarations,
+                            imports,
+                            candidType: 'Tuple'
+                        },
+                        innerTypes: fields
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function generateImports(fields: CandidDefinition[]): Set<string> {
+    const fieldImports = fields.flatMap((field) => [
+        ...field.candidMeta.imports
+    ]);
+    return new Set([...fieldImports, 'IDL']);
+}
+function generateVariableAliasDeclarations(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: CandidDefinition[]
+): string[] {
+    const fieldVariableAliasDeclarations = fields.flatMap(
+        (field) => field.candidMeta.variableAliasDeclarations
+    );
+    if (useTypeDeclaration === true) {
+        const type = [
+            `type ${name} = ${generateCandidTypeAnnotation(
+                false,
+                name,
+                fields
+            )};`
+        ];
+        return [
+            ...fieldVariableAliasDeclarations,
+            `const ${name} = ${generateTypeObject(false, name, fields)};`,
+            ...type
+        ];
+    }
+    return fieldVariableAliasDeclarations;
+}
+
+function generateCandidTypeAnnotation(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: CandidDefinition[]
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    const innerTypesAsString = fields
+        .map((field) => field.candidMeta.typeAnnotation)
+        .join(', ');
+
+    return `[${innerTypesAsString}]`;
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: CandidDefinition[]
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    const innerTypesAsString = fields
+        .map((field) => field.candidMeta.typeObject)
+        .join(', ');
+
+    return `IDL.Tuple(${innerTypesAsString})`;
+}
+
+function generateRuntimeTypeObject(fields: CandidDefinition[]): IDL.Type {
+    const innerTypes = fields.map(
+        (field) => field.candidMeta.runtimeTypeObject
+    );
+
+    return IDL.Tuple(...innerTypes);
+}

package/src/experimental/test/property/arbitraries/candid/constructed/tuple_arb/index.ts

@@ -0,0 +1,31 @@
+import '#experimental/build/assert_experimental';
+
+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 { CandidValueConstraints } from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { TupleDefinitionArb } from './definition_arb';
+import { TupleValuesArb } from './values_arbs';
+
+export type Tuple = CorrespondingJSType[];
+export type ReturnTuple = Tuple | Record<string, never>;
+
+export function TupleArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<Tuple, ReturnTuple>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        TupleDefinitionArb(
+            {
+                ...context,
+                constraints: { maxLength: context.constraints.maxLength }
+            },
+            candidDefinitionArb(context, {})
+        ),
+        TupleValuesArb
+    );
+}

package/src/experimental/test/property/arbitraries/candid/constructed/tuple_arb/values_arbs.ts

@@ -0,0 +1,76 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import { TupleCandidDefinition } from '../../candid_definition_arb/types';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecursiveShapes } from '../../recursive';
+import { ReturnTuple, Tuple } from '.';
+
+export function TupleValuesArb(
+    context: Context<CandidValueConstraints>,
+    tupleDefinition: TupleCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Tuple, ReturnTuple>> {
+    const depthLevel =
+        context.constraints?.depthLevel ?? DEFAULT_VALUE_MAX_DEPTH;
+    const fieldValues = tupleDefinition.innerTypes.map((innerType) => {
+        const result: fc.Arbitrary<CandidValues<CorrespondingJSType>> =
+            CandidValueArb(
+                {
+                    ...context,
+                    constraints: {
+                        ...context.constraints,
+                        depthLevel: depthLevel - 1
+                    }
+                },
+                innerType,
+                recursiveShapes
+            );
+        return result;
+    });
+
+    return fc.tuple(...fieldValues).map((fieldValues) => {
+        const valueLiteral = generateValueLiteral(fieldValues);
+        const agentArgumentValue = generateAgentArgumentValue(fieldValues);
+        const agentResponseValue = generateAgentResponseValue(fieldValues);
+
+        return {
+            valueLiteral,
+            agentArgumentValue,
+            agentResponseValue
+        };
+    });
+}
+
+function generateAgentArgumentValue(
+    fields: CandidValues<CorrespondingJSType>[]
+): Tuple {
+    return fields.map((field) => field.agentArgumentValue);
+}
+
+function generateAgentResponseValue(
+    fields: CandidValues<CorrespondingJSType>[]
+): ReturnTuple {
+    if (fields.length === 0) {
+        return {};
+    }
+    return fields.map((field) => field.agentResponseValue);
+}
+
+function generateValueLiteral(
+    fields: CandidValues<CorrespondingJSType>[]
+): string {
+    const fieldLiterals = fields.map((field) => field.valueLiteral).join(',\n');
+
+    return `[
+        ${fieldLiterals}
+    ]`;
+}

package/src/experimental/test/property/arbitraries/candid/constructed/variant_arb/definition_arbs.ts

@@ -0,0 +1,257 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { IDL } from '#lib/index';
+
+import { JsPropertyNameArb } from '../../../js_name_arb';
+import { Context } from '../../../types';
+import { UniqueIdentifierArb } from '../../../unique_identifier_arb';
+import {
+    CandidDefinition,
+    DefinitionConstraints,
+    RecursiveCandidDefinitionMemo,
+    RecursiveCandidName,
+    VariantCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { RecursiveShapes } from '../../recursive';
+
+type Field = [string, CandidDefinition];
+type FieldAndShapes = [string, WithShapes<CandidDefinition>];
+
+type RuntimeVariant = {
+    [key: string]: IDL.Type;
+};
+
+export function VariantDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArbForFields: RecursiveCandidDefinitionMemo,
+    parents: RecursiveCandidName[]
+): WithShapesArb<VariantCandidDefinition> {
+    const constraints = context.constraints;
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            VariantFieldsArb(context, candidTypeArbForFields, parents),
+            fc.boolean()
+        )
+        .map(
+            ([
+                name,
+                fieldsAndShapes,
+                useTypeDeclarationChance
+            ]): WithShapes<VariantCandidDefinition> => {
+                const useTypeDeclaration =
+                    (constraints.forceInline === undefined ||
+                        constraints.forceInline === false) &&
+                    useTypeDeclarationChance;
+                const fields = fieldsAndShapes.map(
+                    (field): Field => [field[0], field[1].definition]
+                );
+                const recursiveShapes = fieldsAndShapes.reduce(
+                    (acc, field): RecursiveShapes => {
+                        return { ...acc, ...field[1].recursiveShapes };
+                    },
+                    {}
+                );
+                const typeAnnotation = generateCandidTypeAnnotation(
+                    useTypeDeclaration,
+                    name,
+                    fields
+                );
+
+                const typeObject = generateTypeObject(
+                    useTypeDeclaration,
+                    name,
+                    fields
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(fields);
+
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        useTypeDeclaration,
+                        name,
+                        fields
+                    );
+
+                const imports = generateImports(fields);
+
+                return {
+                    definition: {
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            runtimeTypeObject,
+                            variableAliasDeclarations,
+                            imports,
+                            candidType: 'Variant'
+                        },
+                        innerTypes: fields
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function VariantFieldsArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArb: RecursiveCandidDefinitionMemo,
+    parents: RecursiveCandidName[]
+): fc.Arbitrary<FieldAndShapes[]> {
+    // Although no minLength is technically required (according to the
+    // spec), the DFX CLI itself currently errors out trying to pass
+    // an empty object.
+    const VARIANT_MIN_FIELD_COUNT = 1;
+    return fc
+        .uniqueArray(JsPropertyNameArb, {
+            minLength: VARIANT_MIN_FIELD_COUNT,
+            maxLength: context.constraints.maxLength
+        })
+        .chain((fieldsNames) =>
+            fc.tuple(
+                ...fieldsNames.map((name, index) =>
+                    fc.tuple(
+                        fc.constant(name),
+                        possiblyRecursiveArb(
+                            context,
+                            candidTypeArb,
+                            index,
+                            parents
+                        )
+                    )
+                )
+            )
+        );
+}
+
+// Recursion requires at least one of the fields to be a "base case", or in
+// other words it needs to terminate or else we will get an infinitely deep
+// shape. For simplicity we have made the first index always be a base case so
+// we are guaranteed to have at least one. Consequently this function takes the
+// index of the field for which it's generating an arbitrary. If it's 0 then we
+// will not allow a recursive option to be picked for that field. A more
+// complicated approach would involve the guaranteed base case being in any one
+// of the fields, instead of always the first one.
+function possiblyRecursiveArb(
+    context: Context<DefinitionConstraints>,
+    candidArb: RecursiveCandidDefinitionMemo,
+    index: number,
+    parents: RecursiveCandidName[]
+): WithShapesArb<CandidDefinition> {
+    const depthLevel = context.constraints?.depthLevel ?? 0;
+    const newContext = {
+        ...context,
+        constraints: { ...context.constraints, depthLevel: depthLevel - 1 }
+    };
+    return fc.nat(Math.max(parents.length - 1, 0)).chain((randomIndex) => {
+        if (parents.length === 0 || index < 1) {
+            // If there are no recursive parents or this is the first variant field just do a regular arb field
+            return candidArb(newContext, parents)(depthLevel);
+        }
+        return fc.oneof(
+            {
+                arbitrary: fc.constant({
+                    definition: parents[randomIndex],
+                    recursiveShapes: {}
+                }),
+                weight: 1
+            },
+            {
+                arbitrary: candidArb(newContext, parents)(depthLevel),
+                weight: 1
+            }
+        );
+    });
+}
+
+function generateImports(fields: Field[]): Set<string> {
+    const fieldImports = fields.flatMap((field): string[] => [
+        ...field[1].candidMeta.imports
+    ]);
+    return new Set([...fieldImports, 'IDL']);
+}
+
+function generateVariableAliasDeclarations(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: Field[]
+): string[] {
+    const fieldVariableAliasDeclarations = fields.flatMap(
+        (field): string[] => field[1].candidMeta.variableAliasDeclarations
+    );
+    if (useTypeDeclaration === true) {
+        const type = [
+            `type ${name} = ${generateCandidTypeAnnotation(
+                false,
+                name,
+                fields
+            )};`
+        ];
+        return [
+            ...fieldVariableAliasDeclarations,
+            `const ${name} = ${generateTypeObject(false, name, fields)};`,
+            ...type
+        ];
+    }
+    return fieldVariableAliasDeclarations;
+}
+
+function generateCandidTypeAnnotation(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: Field[]
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return fields
+        .map(([fieldName, fieldDataType]) => {
+            const escapedFieldName = fieldName.startsWith('"')
+                ? `"${fieldName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : fieldName;
+            return `{${escapedFieldName}: ${fieldDataType.candidMeta.typeAnnotation}}`;
+        })
+        .join('|');
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    fields: Field[]
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    const fieldsAsString = fields
+        .map(([fieldName, fieldDefinition]) => {
+            const escapedFieldName = fieldName.startsWith('"')
+                ? `"${fieldName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : fieldName;
+            return `${escapedFieldName}: ${fieldDefinition.candidMeta.typeObject}`;
+        })
+        .join(',');
+    return `IDL.Variant({${fieldsAsString}})`;
+}
+
+function generateRuntimeTypeObject(fields: Field[]): IDL.Type {
+    const azleVariantConstructorObj = fields.reduce(
+        (acc, [fieldName, fieldDefinition]): RuntimeVariant => {
+            if (fieldDefinition.candidMeta.runtimeTypeObject === undefined) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [fieldName]: fieldDefinition.candidMeta.runtimeTypeObject
+            };
+        },
+        {}
+    );
+
+    return IDL.Variant(azleVariantConstructorObj);
+}

package/src/experimental/test/property/arbitraries/candid/constructed/variant_arb/index.ts

@@ -0,0 +1,37 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_DEFINITION_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import { candidDefinitionMemo } from '../../candid_definition_arb';
+import { CandidValueAndMeta } from '../../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../../candid_value_and_meta_arb_generator';
+import { CandidValueConstraints } from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { VariantDefinitionArb } from './definition_arbs';
+import { VariantValuesArb } from './values_arb';
+
+export type Variant = {
+    [x: string]: CorrespondingJSType;
+};
+
+export function VariantArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<Variant>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        VariantDefinitionArb(
+            {
+                ...context,
+                constraints: {
+                    depthLevel: DEFAULT_DEFINITION_MAX_DEPTH - 1,
+                    maxLength: context.constraints.maxLength
+                }
+            },
+            candidDefinitionMemo,
+            []
+        ),
+        VariantValuesArb
+    );
+}