@ohos-ports/azle 0.33.0-beta.0

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

@@ -0,0 +1,173 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../types';
+import {
+    CandidDefinition,
+    OptCandidDefinition,
+    RecordCandidDefinition,
+    RecursiveCandidDefinition,
+    RecursiveCandidName,
+    TupleCandidDefinition,
+    VariantCandidDefinition,
+    VecCandidDefinition
+} from './candid_definition_arb/types';
+import { BlobValuesArb } from './constructed/blob_arb/values_arb';
+import { OptValuesArb } from './constructed/opt_arb/values_arb';
+import { RecordValuesArb } from './constructed/record_arb/values_arb';
+import { TupleValuesArb } from './constructed/tuple_arb/values_arbs';
+import { VariantValuesArb } from './constructed/variant_arb/values_arb';
+import { VecValuesArb } from './constructed/vec_arb/values_arb';
+import { CorrespondingJSType } from './corresponding_js_type';
+import { BoolValueArb } from './primitive/bool_arb';
+import {
+    Float32Constraints,
+    Float32ValueArb
+} from './primitive/floats/float32_arb';
+import {
+    Float64Constraints,
+    Float64ValueArb
+} from './primitive/floats/float64_arb';
+import { IntValueArb } from './primitive/ints/int_arb';
+import { Int8ValueArb } from './primitive/ints/int8_arb';
+import { Int16ValueArb } from './primitive/ints/int16_arb';
+import { Int32ValueArb } from './primitive/ints/int32_arb';
+import { Int64ValueArb } from './primitive/ints/int64_arb';
+import { NatValueArb } from './primitive/nats/nat_arb';
+import { Nat8ValueArb } from './primitive/nats/nat8_arb';
+import { Nat16ValueArb } from './primitive/nats/nat16_arb';
+import { Nat32ValueArb } from './primitive/nats/nat32_arb';
+import { Nat64ValueArb } from './primitive/nats/nat64_arb';
+import { NullValueArb } from './primitive/null_arb';
+import { TextConstraints, TextValueArb } from './primitive/text_arb';
+import { VoidValueArb } from './primitive/void_arb';
+import { RecursiveShapes } from './recursive';
+import { RecursiveNameValuesArb } from './recursive/values_arb';
+import { FuncValueArb } from './reference/func_arb/values_arb';
+import { PrincipalValueArb } from './reference/principal_arb';
+import { ServiceValueArb } from './reference/service_arb/values_arb';
+
+export type CandidValues<T extends CorrespondingJSType, E = T> = {
+    agentArgumentValue: T;
+    agentResponseValue: E;
+    valueLiteral: string;
+};
+
+export interface CandidValueConstraints
+    extends TextConstraints,
+        Float32Constraints,
+        Float64Constraints {
+    depthLevel?: number;
+}
+
+export function CandidValueArb(
+    context: Context<CandidValueConstraints>,
+    candidTypeMeta: CandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<CorrespondingJSType>> {
+    const candidType = candidTypeMeta.candidMeta.candidType;
+    if (candidType === 'blob') {
+        return BlobValuesArb();
+    }
+    if (candidType === 'Opt') {
+        return OptValuesArb(
+            context,
+            candidTypeMeta as OptCandidDefinition,
+            recursiveShapes
+        );
+    }
+    if (candidType === 'Record') {
+        return RecordValuesArb(
+            context,
+            candidTypeMeta as RecordCandidDefinition,
+            recursiveShapes
+        );
+    }
+    if (candidType === 'Tuple') {
+        return TupleValuesArb(
+            context,
+            candidTypeMeta as TupleCandidDefinition,
+            recursiveShapes
+        );
+    }
+    if (candidType === 'Variant') {
+        return VariantValuesArb(
+            context,
+            candidTypeMeta as VariantCandidDefinition,
+            recursiveShapes
+        );
+    }
+    if (candidType === 'Vec') {
+        return VecValuesArb(
+            context,
+            candidTypeMeta as VecCandidDefinition,
+            recursiveShapes
+        );
+    }
+    if (candidType === 'bool') {
+        return BoolValueArb();
+    }
+    if (candidType === 'float32') {
+        return Float32ValueArb(context);
+    }
+    if (candidType === 'float64') {
+        return Float64ValueArb(context);
+    }
+    if (candidType === 'int') {
+        return IntValueArb();
+    }
+    if (candidType === 'int8') {
+        return Int8ValueArb();
+    }
+    if (candidType === 'int16') {
+        return Int16ValueArb();
+    }
+    if (candidType === 'int32') {
+        return Int32ValueArb();
+    }
+    if (candidType === 'int64') {
+        return Int64ValueArb();
+    }
+    if (candidType === 'nat') {
+        return NatValueArb();
+    }
+    if (candidType === 'nat8') {
+        return Nat8ValueArb();
+    }
+    if (candidType === 'nat16') {
+        return Nat16ValueArb();
+    }
+    if (candidType === 'nat32') {
+        return Nat32ValueArb();
+    }
+    if (candidType === 'nat64') {
+        return Nat64ValueArb();
+    }
+    if (candidType === 'Null') {
+        return NullValueArb();
+    }
+    if (candidType === 'text') {
+        return TextValueArb(context);
+    }
+    if (candidType === 'Void') {
+        return VoidValueArb();
+    }
+    if (candidType === 'Func') {
+        return FuncValueArb();
+    }
+    if (candidType === 'Principal') {
+        return PrincipalValueArb();
+    }
+    if (candidType === 'Service') {
+        return ServiceValueArb();
+    }
+    if (candidType === 'Recursive') {
+        return RecursiveNameValuesArb(
+            context,
+            candidTypeMeta as RecursiveCandidName | RecursiveCandidDefinition,
+            recursiveShapes
+        );
+    }
+    throw new Error('Unreachable');
+}

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

@@ -0,0 +1,11 @@
+import '#experimental/build/assert_experimental';
+
+import {
+    BlobCandidDefinition,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { SimpleCandidDefinitionArb } from '../../simple_type_arbs/definition_arb';
+
+export function BlobDefinitionArb(): WithShapesArb<BlobCandidDefinition> {
+    return SimpleCandidDefinitionArb('blob');
+}

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

@@ -0,0 +1,19 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../../../types';
+import { CandidValueAndMeta } from '../../candid_value_and_meta_arb';
+import { CandidValueAndMetaArbGenerator } from '../../candid_value_and_meta_arb_generator';
+import { BlobDefinitionArb } from './definition_arb';
+import { BlobValuesArb } from './values_arb';
+
+export function BlobArb(
+    context: Context
+): fc.Arbitrary<CandidValueAndMeta<Uint8Array>> {
+    return CandidValueAndMetaArbGenerator(
+        context,
+        BlobDefinitionArb(),
+        BlobValuesArb
+    );
+}

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

@@ -0,0 +1,11 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { CandidValues } from '../../candid_values_arb';
+import { SimpleCandidValuesArb } from '../../simple_type_arbs/values_arb';
+import { blobToSrcLiteral } from '../../to_src_literal/blob';
+
+export function BlobValuesArb(): fc.Arbitrary<CandidValues<Uint8Array>> {
+    return SimpleCandidValuesArb(fc.uint8Array(), blobToSrcLiteral);
+}

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

@@ -0,0 +1,172 @@
+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,
+    OptCandidDefinition,
+    RecursiveCandidDefinitionMemo,
+    RecursiveCandidName,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+
+export function OptDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    candidTypeArbForInnerType: RecursiveCandidDefinitionMemo,
+    parents: RecursiveCandidName[]
+): WithShapesArb<OptCandidDefinition> {
+    const constraints = context.constraints;
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            possiblyRecursiveArb(context, candidTypeArbForInnerType, parents),
+            fc.boolean()
+        )
+        .map(
+            ([
+                name,
+                innerTypeAndShapes,
+                useTypeDeclarationChance
+            ]): WithShapes<OptCandidDefinition> => {
+                const useTypeDeclaration =
+                    (constraints.forceInline === undefined ||
+                        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: 'Opt'
+                        },
+                        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 || depthLevel < 1) {
+            // If there are no recursive parents or we have reached a depth
+            // level of 0 just do a regular arb inner type
+            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 `[${innerType.candidMeta.typeAnnotation}] | []`;
+}
+
+function generateTypeObject(
+    useTypeDeclaration: boolean,
+    name: string,
+    innerType: CandidDefinition
+): string {
+    if (useTypeDeclaration === true) {
+        return name;
+    }
+
+    return `IDL.Opt(${innerType.candidMeta.typeObject})`;
+}
+
+function generateRuntimeTypeObject(innerType: CandidDefinition): IDL.Type {
+    // TODO IDL.Empty is a placeholder for void...not quite correct
+    return IDL.Opt(innerType.candidMeta.runtimeTypeObject ?? IDL.Empty);
+}

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

@@ -0,0 +1,29 @@
+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 { OptDefinitionArb } from './definition_arb';
+import { OptValuesArb } from './values_arb';
+
+export type Opt = [CorrespondingJSType] | never[];
+
+export function OptArb(
+    context: Context<CandidValueConstraints>
+): fc.Arbitrary<CandidValueAndMeta<Opt>> {
+    const definitionContext = {
+        ...context,
+        constraints: { depthLevel: DEFAULT_DEFINITION_MAX_DEPTH - 1 }
+    };
+    return CandidValueAndMetaArbGenerator(
+        context,
+        OptDefinitionArb(definitionContext, candidDefinitionMemo, []),
+        OptValuesArb
+    );
+}

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

@@ -0,0 +1,88 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { DEFAULT_VALUE_MAX_DEPTH } from '../../../config';
+import { Context } from '../../../types';
+import { OptCandidDefinition } from '../../candid_definition_arb/types';
+import {
+    CandidValueArb,
+    CandidValueConstraints,
+    CandidValues
+} from '../../candid_values_arb';
+import { CorrespondingJSType } from '../../corresponding_js_type';
+import { RecursiveShapes } from '../../recursive';
+import { Opt } from '.';
+
+type SomeOrNone = 'Some' | 'None';
+
+export function OptValuesArb(
+    context: Context<CandidValueConstraints>,
+    optDefinition: OptCandidDefinition,
+    recursiveShapes: RecursiveShapes
+): fc.Arbitrary<CandidValues<Opt>> {
+    const constraints = context.constraints ?? {
+        depthLevel: DEFAULT_VALUE_MAX_DEPTH
+    };
+    const depthLevel = constraints.depthLevel ?? DEFAULT_VALUE_MAX_DEPTH;
+    if (depthLevel < 1) {
+        return fc.constant(generateNoneValue());
+    }
+    const innerValue = fc.tuple(
+        fc.constantFrom('Some', 'None') as fc.Arbitrary<SomeOrNone>,
+        CandidValueArb(
+            {
+                constraints: { ...constraints, depthLevel: depthLevel - 1 }
+            },
+            optDefinition.innerType,
+            recursiveShapes
+        )
+    );
+
+    return innerValue.map(([someOrNone, innerType]) => {
+        const valueLiteral = generateValueLiteral(someOrNone, innerType);
+        const agentArgumentValue = generateValue(someOrNone, innerType);
+        const agentResponseValue = generateValue(someOrNone, innerType, true);
+
+        return {
+            valueLiteral,
+            agentArgumentValue,
+            agentResponseValue
+        };
+    });
+}
+
+function generateNoneValue(): CandidValues<Opt> {
+    return {
+        valueLiteral: '[]',
+        agentArgumentValue: [],
+        agentResponseValue: []
+    };
+}
+
+function generateValue(
+    someOrNone: SomeOrNone,
+    innerType: CandidValues<CorrespondingJSType>,
+    useAgentResponseValue: boolean = false
+): Opt {
+    if (someOrNone === 'Some') {
+        return [
+            useAgentResponseValue
+                ? innerType.agentResponseValue
+                : innerType.agentArgumentValue
+        ];
+    } else {
+        return [];
+    }
+}
+
+function generateValueLiteral(
+    someOrNone: SomeOrNone,
+    innerType: CandidValues<CorrespondingJSType>
+): string {
+    if (someOrNone === 'Some') {
+        return `[${innerType.valueLiteral}]`;
+    } else {
+        return '[]';
+    }
+}

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

@@ -0,0 +1,184 @@
+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,
+    CandidDefinitionArb,
+    DefinitionConstraints,
+    RecordCandidDefinition,
+    WithShapes,
+    WithShapesArb
+} from '../../candid_definition_arb/types';
+import { RecursiveShapes } from '../../recursive';
+
+type Field = [string, CandidDefinition];
+
+type RuntimeRecord = {
+    [key: string]: IDL.Type;
+};
+
+export function RecordDefinitionArb(
+    context: Context<DefinitionConstraints>,
+    fieldCandidDefArb: CandidDefinitionArb
+): WithShapesArb<RecordCandidDefinition> {
+    return fc
+        .tuple(
+            UniqueIdentifierArb('globalNames'),
+            fc.uniqueArray(fc.tuple(JsPropertyNameArb, fieldCandidDefArb), {
+                selector: ([name, _]) => name,
+                minLength: 1, // Zero length records are giving that same null error 'vec length of zero sized values too large' // I don't know if that's the same error but it seems like it is
+                maxLength: context.constraints.maxLength
+                // https://github.com/demergent-labs/azle/issues/1453
+            }),
+            fc.boolean()
+        )
+        .map(
+            ([
+                name,
+                fieldsAndShapes,
+                useTypeDeclaration
+            ]): WithShapes<RecordCandidDefinition> => {
+                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: 'Record'
+                        },
+                        innerTypes: fields
+                    },
+                    recursiveShapes
+                };
+            }
+        );
+}
+
+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, fieldDefinition]) => {
+            const escapedFieldName = fieldName.startsWith('"')
+                ? `"${fieldName.slice(1, -1).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+                : fieldName;
+            return `${escapedFieldName}: ${fieldDefinition.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.Record({${fieldsAsString}})`;
+}
+
+function generateRuntimeTypeObject(fields: Field[]): IDL.Type {
+    const azleRecordConstructorObj = fields.reduce(
+        (acc, [fieldName, fieldDefinition]): RuntimeRecord => {
+            if (fieldDefinition.candidMeta.runtimeTypeObject === undefined) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [fieldName]: fieldDefinition.candidMeta.runtimeTypeObject
+            };
+        },
+        {}
+    );
+
+    return IDL.Record(azleRecordConstructorObj);
+}