ICP API prop test types

tests/property/ic_api/arg_data_raw/test/generate_canister.ts

@@ -21,6 +21,7 @@ ${imports
     .map((importDeclaration) => `import { ${importDeclaration} } from 'azle';`)
     .join('\n')}
 ${variableAliasDeclarations.join('\n')}
+import { AssertType, NotAnyAndExact } from 'azle/type_tests/assert_type';
 
 export default class {
     initArgDataRaw: Uint8Array | null = null;
@@ -68,6 +69,19 @@ export default class {
     candidEncode(arg: string): Uint8Array {
         return candidEncode(arg);
     }
+
+    @query([], IDL.Bool)
+    argDataRawTypesAreCorrect(): boolean {
+        return argDataRaw() instanceof Uint8Array;
+    }
+
+    @query([], IDL.Bool)
+    assertTypes(): boolean {
+        type _AssertReturnType = AssertType<
+            NotAnyAndExact<ReturnType<typeof argDataRaw>, Uint8Array>
+        >;
+        return argDataRaw() instanceof Uint8Array;
+    }
 }
     `;
 }

tests/property/ic_api/arg_data_raw/test/tests.ts

@@ -76,6 +76,8 @@ export function getTests(): Test {
                             console.info('Update method iteration:', i);
                             await testCanisterMethod(updateArgDef, 'Update');
                         }
+
+                        expect(await actor.assertTypes()).toBe(true);
                     }
                 ),
                 defaultPropTestParams()

tests/property/ic_api/caller/src/index.ts

@@ -12,6 +12,7 @@ import {
     StableBTreeMap,
     update
 } from 'azle';
+import { AssertType, NotAnyAndExact } from 'azle/type_tests/assert_type';
 
 export default class {
     initCaller: Principal | null = null;
@@ -98,4 +99,12 @@ export default class {
     getUpdateCaller(): Principal {
         return caller();
     }
+
+    @query([], IDL.Bool)
+    assertTypes(): boolean {
+        type _AssertReturnType = AssertType<
+            NotAnyAndExact<ReturnType<typeof caller>, Principal>
+        >;
+        return caller() instanceof Principal;
+    }
 }

tests/property/ic_api/caller/test/tests.ts

@@ -135,5 +135,10 @@ export function getTests(): Test {
                 defaultPropTestParams()
             );
         });
+
+        it('asserts caller static and runtime types', async () => {
+            const actor = await getCanisterActor<Actor>('canister');
+            expect(await actor.assertTypes()).toBe(true);
+        });
     };
 }

tests/property/ic_api/candid/src/index.ts

@@ -1,4 +1,5 @@
 import { candidDecode, candidEncode, IDL, query } from 'azle';
+import { AssertType, NotAnyAndExact } from 'azle/type_tests/assert_type';
 
 export default class {
     @query([IDL.Vec(IDL.Nat8)], IDL.Text)
@@ -10,4 +11,32 @@ export default class {
     candidEncodeQuery(candidString: string): Uint8Array {
         return candidEncode(candidString);
     }
+
+    @query([IDL.Vec(IDL.Nat8)], IDL.Bool)
+    assertCandidDecodeTypes(candidBytes: Uint8Array): boolean {
+        type _AssertParamType = AssertType<
+            NotAnyAndExact<Parameters<typeof candidDecode>[0], Uint8Array>
+        >;
+        type _AssertReturnType = AssertType<
+            NotAnyAndExact<ReturnType<typeof candidDecode>, string>
+        >;
+        return (
+            candidBytes instanceof Uint8Array &&
+            typeof candidDecode(candidBytes) === 'string'
+        );
+    }
+
+    @query([IDL.Text], IDL.Bool)
+    assertCandidEncodeTypes(candidString: string): boolean {
+        type _AssertParamType = AssertType<
+            NotAnyAndExact<Parameters<typeof candidEncode>[0], string>
+        >;
+        type _AssertReturnType = AssertType<
+            NotAnyAndExact<ReturnType<typeof candidEncode>, Uint8Array>
+        >;
+        return (
+            typeof candidString === 'string' &&
+            candidEncode(candidString) instanceof Uint8Array
+        );
+    }
 }

tests/property/ic_api/candid/test/tests.ts

@@ -90,5 +90,19 @@ export function getTests(): Test {
                 defaultPropTestParams()
             );
         });
+
+        it('asserts candidDecode static and runtime types', async () => {
+            const actor = await getCanisterActor<Actor>('canister');
+            expect(
+                await actor.assertCandidDecodeTypes(
+                    new Uint8Array([68, 73, 68, 76, 0, 1, 113, 0])
+                )
+            ).toBe(true);
+        });
+
+        it('asserts candidEncode static and runtime types', async () => {
+            const actor = await getCanisterActor<Actor>('canister');
+            expect(await actor.assertCandidEncodeTypes('("")')).toBe(true);
+        });
     };
 }