Arg data raw prop test

tests/property/ic_api/arg_data_raw/.gitignore

@@ -0,0 +1,4 @@
+.azle
+.dfx
+dfx_generated
+node_modules

tests/property/ic_api/arg_data_raw/dfx.json

@@ -0,0 +1,13 @@
+{
+    "canisters": {
+        "canister": {
+            "type": "azle",
+            "main": "src/index.ts",
+            "init_arg": "(\"\")",
+            "declarations": {
+                "output": "test/dfx_generated/canister",
+                "node_compatibility": true
+            }
+        }
+    }
+}

tests/property/ic_api/arg_data_raw/jest.config.js

@@ -0,0 +1,12 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    bail: true,
+    testTimeout: 100_000_000,
+    transform: {
+        '^.+\\.ts$': ['ts-jest', { isolatedModules: true }],
+        '^.+\\.js$': 'ts-jest'
+    },
+    transformIgnorePatterns: ['/node_modules/(?!(azle)/)'] // Make sure azle is transformed
+};

tests/property/ic_api/arg_data_raw/package.json

@@ -0,0 +1,17 @@
+{
+    "scripts": {
+        "pretest": "tsx test/pretest.ts",
+        "test": "jest"
+    },
+    "dependencies": {
+        "azle": "0.24.1"
+    },
+    "devDependencies": {
+        "@dfinity/agent": "^2.0.0",
+        "@dfinity/principal": "^2.0.0",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.4",
+        "tsx": "^4.15.7",
+        "typescript": "^5.2.2"
+    }
+}

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

@@ -0,0 +1,61 @@
+import {
+    argDataRaw,
+    candidEncode,
+    IDL,
+    init,
+    postUpgrade,
+    query,
+    update
+} from 'azle';
+
+export default class {
+    initArgDataRaw: Uint8Array | null = null;
+    postUpgradeArgDataRaw: Uint8Array | null = null;
+
+    @init([IDL.Text])
+    init(arg: string): void {
+        console.log('init', arg);
+        this.initArgDataRaw = argDataRaw();
+    }
+
+    @query([], IDL.Opt(IDL.Vec(IDL.Nat8)))
+    getInitArgDataRaw(): [Uint8Array] | [] {
+        if (this.initArgDataRaw === null) {
+            return [];
+        } else {
+            return [this.initArgDataRaw];
+        }
+    }
+
+    @postUpgrade([IDL.Text])
+    postUpgrade(arg: string): void {
+        console.log('postUpgrade', arg);
+        this.postUpgradeArgDataRaw = argDataRaw();
+    }
+
+    @query([], IDL.Opt(IDL.Vec(IDL.Nat8)))
+    getPostUpgradeArgDataRaw(): [Uint8Array] | [] {
+        if (this.postUpgradeArgDataRaw === null) {
+            return [];
+        } else {
+            return [this.postUpgradeArgDataRaw];
+        }
+    }
+
+    @query([IDL.Text], IDL.Vec(IDL.Nat8))
+    getQueryArgDataRaw(arg: string): Uint8Array {
+        console.log('query', arg);
+        return argDataRaw();
+    }
+
+    @update([IDL.Text], IDL.Vec(IDL.Nat8))
+    getUpdateArgDataRaw(arg: string): Uint8Array {
+        console.log('update', arg);
+        return argDataRaw();
+    }
+
+    @query([IDL.Text], IDL.Vec(IDL.Nat8))
+    candidEncode(arg: string): Uint8Array {
+        return candidEncode(arg);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process';
+
+function pretest(): void {
+    execSync(`dfx canister uninstall-code canister || true`, {
+        stdio: 'inherit'
+    });
+
+    execSync(`dfx deploy canister`, {
+        stdio: 'inherit'
+    });
+
+    execSync(`dfx generate canister`, {
+        stdio: 'inherit'
+    });
+}
+
+pretest();

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

@@ -0,0 +1,5 @@
+import { runTests } from 'azle/test';
+
+import { getTests } from './tests';
+
+runTests(getTests());

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

@@ -0,0 +1,109 @@
+import {
+    defaultPropTestParams,
+    expect,
+    getCanisterActor,
+    it,
+    Test
+} from 'azle/test';
+import { execSync } from 'child_process';
+import fc from 'fast-check';
+
+import { _SERVICE as Actor } from './dfx_generated/canister/canister.did';
+
+export function getTests(): Test {
+    return () => {
+        it('gets the init arg data raw from the canister', async () => {
+            await fc.assert(
+                fc.asyncProperty(
+                    // TODO once we figure out how to escape single quotes in candid strings
+                    // we can use fc.string() instead of fc.string().filter((s) => !s.includes("'"))
+                    fc.string().filter((s) => !s.includes("'")),
+                    fc.string().filter((s) => !s.includes("'")),
+                    fc.string().filter((s) => !s.includes("'")),
+                    fc.string().filter((s) => !s.includes("'")),
+                    async (
+                        initArgData,
+                        postUpgradeArgData,
+                        queryArgData,
+                        updateArgData
+                    ) => {
+                        execSync(
+                            `dfx canister uninstall-code canister || true`,
+                            {
+                                stdio: 'inherit'
+                            }
+                        );
+
+                        const initArgDataCandidString = `("${escapeArgData(
+                            initArgData
+                        )}")`;
+
+                        execSync(
+                            `dfx deploy canister --argument '${initArgDataCandidString}'`,
+                            {
+                                stdio: 'inherit'
+                            }
+                        );
+
+                        const actor = await getCanisterActor<Actor>('canister');
+                        const initArgDataRaw = await actor.getInitArgDataRaw();
+                        const expectedInitArgDataRaw = await actor.candidEncode(
+                            initArgDataCandidString
+                        );
+                        expect(initArgDataRaw).toEqual([
+                            expectedInitArgDataRaw
+                        ]);
+
+                        const queryArgDataCandidString = `("${escapeArgData(
+                            queryArgData
+                        )}")`;
+                        const queryArgDataRaw =
+                            await actor.getQueryArgDataRaw(queryArgData);
+                        const expectedQueryArgDataRaw =
+                            await actor.candidEncode(queryArgDataCandidString);
+                        expect(queryArgDataRaw).toEqual(
+                            expectedQueryArgDataRaw
+                        );
+
+                        const updateArgDataCandidString = `("${escapeArgData(
+                            updateArgData
+                        )}")`;
+                        const updateArgDataRaw =
+                            await actor.getUpdateArgDataRaw(updateArgData);
+                        const expectedUpdateArgDataRaw =
+                            await actor.candidEncode(updateArgDataCandidString);
+                        expect(updateArgDataRaw).toEqual(
+                            expectedUpdateArgDataRaw
+                        );
+
+                        const postUpgradeArgDataCandidString = `("${escapeArgData(
+                            postUpgradeArgData
+                        )}")`;
+
+                        execSync(
+                            `dfx deploy canister --argument '${postUpgradeArgDataCandidString}' --upgrade-unchanged`,
+                            {
+                                stdio: 'inherit'
+                            }
+                        );
+
+                        const postUpgradeArgDataRaw =
+                            await actor.getPostUpgradeArgDataRaw();
+                        const expectedPostUpgradeArgDataRaw =
+                            await actor.candidEncode(
+                                postUpgradeArgDataCandidString
+                            );
+                        expect(postUpgradeArgDataRaw).toEqual([
+                            expectedPostUpgradeArgDataRaw
+                        ]);
+                    }
+                ),
+                defaultPropTestParams
+            );
+        });
+    };
+}
+
+function escapeArgData(data: string): string {
+    return data.replace(/[\\"]/g, '\\$&');
+}

tests/property/ic_api/arg_data_raw/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "target": "ES2020",
+        "module": "ES2020",
+        "moduleResolution": "node",
+        "allowJs": true,
+        "outDir": "HACK_BECAUSE_OF_ALLOW_JS"
+    }
+}