@ohos-ports/azle 0.33.0-beta.0

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

@@ -0,0 +1,92 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import { VariantCandidDefinition } from '../../candid_definition_arb/types';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecursiveShapes } from '../../recursive';
+import { Variant } from '.';
+
+type Field = [string, CandidValues<CorrespondingJSType>];
+
+export function VariantValuesArb(
+    context: Context<CandidValueConstraints>,
+    variantDefinition: VariantCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Variant>> {
+    const depthLevel =
+        context.constraints?.depthLevel ?? DEFAULT_VALUE_MAX_DEPTH;
+    return fc
+        .nat(depthLevel < 1 ? 0 : variantDefinition.innerTypes.length - 1)
+        .chain((randomIndex) => {
+            if (variantDefinition.innerTypes.length === 0) {
+                return fc.constant({
+                    valueLiteral: '{}',
+                    agentArgumentValue: {},
+                    agentResponseValue: {}
+                });
+            }
+
+            const [name, innerType] = variantDefinition.innerTypes[randomIndex];
+
+            const fieldValues = CandidValueArb(
+                {
+                    ...context,
+                    constraints: {
+                        ...context.constraints,
+                        depthLevel: depthLevel - 1
+                    }
+                },
+                innerType,
+                recursiveShapes
+            ).map((values): Field => {
+                return [name, values];
+            });
+
+            return fieldValues.map((fieldValue) => {
+                const valueLiteral = generateValueLiteral(fieldValue);
+                const agentArgumentValue = generateValue(fieldValue);
+                const agentResponseValue = generateValue(fieldValue, true);
+
+                return {
+                    valueLiteral,
+                    agentArgumentValue,
+                    agentResponseValue
+                };
+            });
+        });
+}
+
+function generateValue(field: Field, returned: boolean = false): Variant {
+    const [fieldName, { agentArgumentValue, agentResponseValue }] = field;
+
+    const normalizedFieldName =
+        fieldName.startsWith('"') && fieldName.endsWith('"')
+            ? fieldName.slice(1, -1)
+            : fieldName;
+
+    return {
+        [normalizedFieldName]: returned
+            ? agentResponseValue
+            : agentArgumentValue
+    };
+}
+
+function generateValueLiteral(field: Field): string {
+    const [fieldName, fieldValue] = field;
+
+    return `{
+        ${
+            fieldName.startsWith('"')
+                ? `"${fieldName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : fieldName
+        }: ${fieldValue.valueLiteral}
+    }`;
+}

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

@@ -0,0 +1,203 @@
+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,
+    RecursiveCandidDefinitionMemo,
+    RecursiveCandidName,
+    VecCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+
+export function VecDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArb: RecursiveCandidDefinitionMemo,
+    parents: RecursiveCandidName[]
+): WithShapesArb<VecCandidDefinition> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            possiblyRecursiveArb(context, candidTypeArb, parents),
+            fc.boolean()
+        )
+        .map(
+            ([
+                name,
+                innerTypeAndShapes,
+                useTypeDeclarationChance
+            ]): WithShapes<VecCandidDefinition> => {
+                const useTypeDeclaration =
+                    (context.constraints.forceInline === undefined ||
+                        context.constraints.forceInline === false) &&
+                    useTypeDeclarationChance;
+                const { definition: innerType, recursiveShapes } =
+                    innerTypeAndShapes;
+                const typeAnnotation = generateCandidTypeAnnotation(
+                    useTypeDeclaration,
+                    name,
+                    innerType
+                );
+
+                const typeObject = generateTypeObject(
+                    useTypeDeclaration,
+                    name,
+                    innerType
+                );
+
+                const runtimeTypeObject = generateRuntimeTypeObject(innerType);
+
+                const variableAliasDeclarations =
+                    generateVariableAliasDeclarations(
+                        useTypeDeclaration,
+                        name,
+                        innerType
+                    );
+
+                const imports = generateImports(innerType);
+
+                return {
+                    definition: {
+                        candidMeta: {
+                            typeAnnotation,
+                            typeObject,
+                            runtimeTypeObject,
+                            variableAliasDeclarations,
+                            imports,
+                            candidType: 'Vec'
+                        },
+                        innerType: innerType
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+function possiblyRecursiveArb(
+    context: Context<DefinitionConstraints>,
+    candidArb: RecursiveCandidDefinitionMemo,
+    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) {
+            // 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(innerType: CandidDefinition): Set<string> {
+    return new Set([...innerType.candidMeta.imports, 'IDL']);
+}
+
+function generateVariableAliasDeclarations(
+    useTypeDeclaration: boolean,
+    name: string,
+    innerType: CandidDefinition
+): string[] {
+    if (useTypeDeclaration === true) {
+        const type = [
+            `type ${name} = ${generateCandidTypeAnnotation(
+                false,
+                name,
+                innerType
+            )};`
+        ];
+        return [
+            ...innerType.candidMeta.variableAliasDeclarations,
+            `const ${name} = ${generateTypeObject(false, name, innerType)};`,
+            ...type
+        ];
+    }
+    return innerType.candidMeta.variableAliasDeclarations;
+}
+
+function generateCandidTypeAnnotation(
+    useTypeDeclaration: boolean,
+    name: string,
+    innerType: CandidDefinition
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return toClassTypeAnnotation(innerType);
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    innerType: CandidDefinition
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return `IDL.Vec(${innerType.candidMeta.typeObject})`;
+}
+
+function generateRuntimeTypeObject(innerType: CandidDefinition): IDL.Type {
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    return IDL.Vec(innerType.candidMeta.runtimeTypeObject ?? IDL.Empty);
+}
+
+function toClassTypeAnnotation(innerType: CandidDefinition): string {
+    if (innerType.candidMeta.candidType === 'int64') {
+        return `BigInt64Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'int32') {
+        return `Int32Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'int16') {
+        return `Int16Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'int8') {
+        return `Int8Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'nat64') {
+        return `BigUint64Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'nat32') {
+        return `Uint32Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'nat16') {
+        return `Uint16Array`;
+    }
+
+    if (innerType.candidMeta.candidType === 'nat8') {
+        return `Uint8Array`;
+    }
+
+    return `(${innerType.candidMeta.typeAnnotation})[]`;
+}

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

@@ -0,0 +1,39 @@
+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 { VecDefinitionArb } from './definition_arb';
+import { VecValuesArb } from './values_arb';
+
+export type Vec =
+    | CorrespondingJSType[]
+    | Uint16Array
+    | Uint32Array
+    | Uint8Array
+    | Int16Array
+    | Int32Array
+    | Int8Array
+    | BigUint64Array
+    | BigInt64Array;
+
+export function VecArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<Vec>> {
+    const definitionContext = {
+        ...context,
+        constraints: { depthLevel: DEFAULT_DEFINITION_MAX_DEPTH }
+    };
+    const valueContext = { ...context };
+    return CandidValueAndMetaArbGenerator(
+        valueContext,
+        VecDefinitionArb(definitionContext, candidDefinitionMemo, []),
+        VecValuesArb
+    );
+}

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

@@ -0,0 +1,257 @@
+import '#experimental/build/assert_experimental';
+
+import fc, { ArrayConstraints } from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import {
+    CandidDefinition,
+    OptCandidDefinition,
+    RecordCandidDefinition,
+    TupleCandidDefinition,
+    VariantCandidDefinition,
+    VecCandidDefinition
+} from '../../candid_definition_arb/types';
+import { CandidType } from '../../candid_type';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecursiveShapes } from '../../recursive';
+import { Vec } from '.';
+
+/*
+https://github.com/dfinity/candid/blob/491969f34dd791e51f69c5f8d3c6192ae405b839/spec/Candid.md#memory
+Set size limit to follow candid spec
+const NULL_VEC_SIZE_LIMIT = 2_000_000;
+*/
+// TODO set to zero until the limit is unified on both the canister and client side as per https://github.com/demergent-labs/azle/issues/1538
+const EMPTYISH_VEC_SIZE_LIMIT = 0;
+
+export function VecValuesArb(
+    context: Context<CandidValueConstraints>,
+    vecDefinition: VecCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Vec>> {
+    const depthLevel =
+        context.constraints?.depthLevel ?? DEFAULT_VALUE_MAX_DEPTH;
+    if (depthLevel < 1) {
+        return fc.constant(
+            generateEmptyVec(vecDefinition.innerType.candidMeta.candidType)
+        );
+    }
+    const arbitraryMemberValues = fc
+        .tuple(
+            fc.array(
+                fc.constant(null),
+                determineVecConstraints(
+                    vecDefinition,
+                    context.constraints?.maxLength
+                )
+            ),
+            fc.constant(vecDefinition.innerType)
+        )
+        .chain(([arrayTemplate, innerType]) =>
+            fc.tuple(
+                ...arrayTemplate.map(() =>
+                    CandidValueArb(
+                        {
+                            ...context,
+                            constraints: {
+                                ...context.constraints,
+                                depthLevel: depthLevel - 1
+                            }
+                        },
+                        innerType,
+                        recursiveShapes
+                    )
+                )
+            )
+        );
+
+    const innerCandidType = vecDefinition.innerType.candidMeta.candidType;
+
+    return arbitraryMemberValues.map((fieldValues) => {
+        const valueLiteral = generateValueLiteral(fieldValues, innerCandidType);
+        const agentArgumentValue = generateValue(fieldValues, innerCandidType);
+        const agentResponseValue = generateValue(
+            fieldValues,
+            innerCandidType,
+            true
+        );
+        return {
+            valueLiteral,
+            agentArgumentValue,
+            agentResponseValue
+        };
+    });
+}
+
+function determineVecConstraints(
+    vecDefinition: VecCandidDefinition,
+    maxLength: number = 10
+): ArrayConstraints | undefined {
+    if (isEmptyInnerType(vecDefinition.innerType)) {
+        return { maxLength: EMPTYISH_VEC_SIZE_LIMIT };
+    }
+
+    return {
+        size: 'max',
+        maxLength
+    };
+}
+
+function generateEmptyVec(innerCandidType: CandidType): CandidValues<Vec> {
+    return {
+        valueLiteral: typeValueLiteral('[]', innerCandidType),
+        agentArgumentValue: typeArray([], innerCandidType),
+        agentResponseValue: typeArray([], innerCandidType)
+    };
+}
+
+function generateValue<T extends CorrespondingJSType>(
+    array: CandidValues<T>[],
+    innerCandidType: CandidType,
+    returned: boolean = false
+): Vec {
+    const value = array.map((sample) =>
+        returned ? sample.agentResponseValue : sample.agentArgumentValue
+    );
+
+    return typeArray(value, innerCandidType);
+}
+
+function generateValueLiteral<T extends CorrespondingJSType>(
+    sample: CandidValues<T>[],
+    innerCandidType: CandidType
+): string {
+    const valueLiterals = sample.map((sample) => sample.valueLiteral).join(',');
+
+    const valueLiteral = `[${valueLiterals}]`;
+
+    return typeValueLiteral(valueLiteral, innerCandidType);
+}
+
+function typeValueLiteral(
+    arrayLiteral: string,
+    innerCandidType: CandidType
+): string {
+    if (innerCandidType === 'int64') {
+        return `BigInt64Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'int32') {
+        return `Int32Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'int16') {
+        return `Int16Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'int8') {
+        return `Int8Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'nat64') {
+        return `BigUint64Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'nat32') {
+        return `Uint32Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'nat16') {
+        return `Uint16Array.from(${arrayLiteral})`;
+    }
+
+    if (innerCandidType === 'nat8') {
+        return `Uint8Array.from(${arrayLiteral})`;
+    }
+
+    return arrayLiteral;
+}
+
+function typeArray<T extends CorrespondingJSType>(
+    arr: T[],
+    innerCandidType: CandidType
+): Vec {
+    if (innerCandidType === 'int8') {
+        return new Int8Array(arr as number[]);
+    }
+    if (innerCandidType === 'int16') {
+        return new Int16Array(arr as number[]);
+    }
+    if (innerCandidType === 'int32') {
+        return new Int32Array(arr as number[]);
+    }
+    if (innerCandidType === 'int64') {
+        return new BigInt64Array(arr as bigint[]);
+    }
+    if (innerCandidType === 'nat8') {
+        return new Uint8Array(arr as number[]);
+    }
+    if (innerCandidType === 'nat16') {
+        return new Uint16Array(arr as number[]);
+    }
+    if (innerCandidType === 'nat32') {
+        return new Uint32Array(arr as number[]);
+    }
+    if (innerCandidType === 'nat64') {
+        return new BigUint64Array(arr as bigint[]);
+    }
+
+    return arr;
+}
+
+/**
+ * In order to prevent DoS attacks empty inner types can only be of length 0.
+ * Empty types are null, empty record, empty tuple, record with one field that
+ * is a null, tuple with one field that is a null.
+ * Lets start with a vec or null, or vec or tuple where all the fields are null,
+ * or vec or record where all things are null or vec or variant where things are
+ * null
+ * https://github.com/demergent-labs/azle/issues/1524
+ * @param innerType
+ * @returns
+ */
+function isEmptyInnerType(innerType: CandidDefinition): boolean {
+    if (innerType.candidMeta.candidType === 'Null') {
+        return true;
+    }
+    if (
+        innerType.candidMeta.candidType === 'Record' ||
+        innerType.candidMeta.candidType === 'Tuple' ||
+        innerType.candidMeta.candidType === 'Variant' ||
+        innerType.candidMeta.candidType === 'Opt'
+    ) {
+        return areAllFieldsNull(innerType);
+    }
+    return false;
+}
+
+function areAllFieldsNull(innerType: CandidDefinition): boolean {
+    if (
+        innerType.candidMeta.candidType === 'Record' ||
+        innerType.candidMeta.candidType === 'Variant'
+    ) {
+        const multiInnerType = innerType as
+            | RecordCandidDefinition
+            | VariantCandidDefinition;
+        return multiInnerType.innerTypes.every((innerType) =>
+            isEmptyInnerType(innerType[1])
+        );
+    }
+    if (innerType.candidMeta.candidType === 'Tuple') {
+        const multiInnerType = innerType as TupleCandidDefinition;
+        return multiInnerType.innerTypes.every((innerType) =>
+            isEmptyInnerType(innerType)
+        );
+    }
+    if (innerType.candidMeta.candidType === 'Opt') {
+        const optInnerType = innerType as OptCandidDefinition;
+        return isEmptyInnerType(optInnerType.innerType);
+    }
+    return false;
+}

package/src/experimental/test/property/arbitraries/candid/corresponding_js_type.ts

@@ -0,0 +1,34 @@
+import '#experimental/build/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+
+import { Opt } from './constructed/opt_arb';
+import { Record } from './constructed/record_arb';
+import { Tuple } from './constructed/tuple_arb';
+import { Variant } from './constructed/variant_arb';
+import { Vec } from './constructed/vec_arb';
+import { Func } from './reference/func_arb';
+
+export type CorrespondingJSType =
+    | number
+    | bigint
+    | null
+    | boolean
+    | Principal
+    | Uint8Array
+    | string
+    | Func
+    | Opt
+    | Variant
+    | Record
+    | Tuple
+    | undefined
+    | Int16Array
+    | Int32Array
+    | Int8Array
+    | BigInt64Array
+    | Uint16Array
+    | Uint32Array
+    | Uint8Array
+    | BigUint64Array
+    | Vec;

package/src/experimental/test/property/arbitraries/candid/primitive/bool_arb.ts

@@ -0,0 +1,28 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../../types';
+import { BoolCandidDefinition } from '../candid_definition_arb/types';
+import { WithShapesArb } from '../candid_definition_arb/types';
+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 { booleanToSrcLiteral } from '../to_src_literal/boolean';
+
+export function BoolArb(context: Context): fc.Arbitrary<any> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        BoolDefinitionArb(),
+        BoolValueArb
+    );
+}
+
+export function BoolDefinitionArb(): WithShapesArb<BoolCandidDefinition> {
+    return SimpleCandidDefinitionArb('bool');
+}
+
+export function BoolValueArb(): fc.Arbitrary<CandidValues<boolean>> {
+    return SimpleCandidValuesArb(fc.boolean(), booleanToSrcLiteral);
+}