Update flow-cadut dependency. Introduce bootstrap utility (#46)

* Create metadata tests

* Update flow-cadut version.
Fix jest config

* Fix logging for emulator exit

* Disable logging in tests

* Prettify

* Setup bin field. Add Prettier config. Install yargs package

* Setup bin executable

* Create templates, commands and CLI processor

* Add make command

* Refactor imports

* Bump version

* CHANGELOG added

* Add flag to make command to specify base path

* Create documentation for bootstrap utility

* Set jest matcher

* Remove prettier duplicate

* Update fcl dependency

* Add more templates for dev tests

* Add proposed changes

* Destructure arguments in short notation based on interaction type

* Update dev tests

* Bump @onflow/types

* Prettify

* Move isObject to utils module

* Refactor deployByName to allow short notation

* Add dev tests for deployment methods

* Add header

* Prettify

* Refactor prefix

Author: Maksim Daunarovich

CHANGELOG.md

@@ -0,0 +1,5 @@
+### 0.1.13 - 2021-07-28
+
+- Bootstrap utility added to framework
+- Update `flow-cadut` dependency and fixed support for complex types
+- Fixed issue with emulator throwing an error with `logging` flag set to `true`

babel.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-    presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+  presets: [["@babel/preset-env", { targets: { node: "current" } }]],
 };

bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("esm")(module /*, options*/)("../src/cli").run(process.argv);

dev-test/cadence/scripts/log-message.cdc

@@ -1,3 +1,4 @@
-pub fun main(){
+pub fun main(): Int{
     log("hello from cadence")
+    return 42
 }

dev-test/cadence/scripts/log-passed-message.cdc

@@ -0,0 +1,4 @@
+pub fun main(message: String):String{
+    log(message)
+    return message
+}

dev-test/cadence/transactions/log-message.cdc

@@ -0,0 +1,5 @@
+transaction(message:String){
+    prepare(signer: AuthAccount){
+        log(message)
+    }
+}

dev-test/deploy.test.js

@@ -0,0 +1,59 @@
+import path from "path";
+import {
+  emulator,
+  init,
+  deployContractByName,
+  getContractAddress,
+  getAccountAddress,
+  getServiceAddress,
+} from "../src";
+
+// We need to set timeout for a higher number, cause some transactions might take up some time
+jest.setTimeout(10000);
+
+describe("interactions - sendTransaction", () => {
+  // Instantiate emulator and path to Cadence files
+  beforeEach(async () => {
+    const basePath = path.resolve(__dirname, "./cadence");
+    const port = 8080;
+    await init(basePath, { port });
+    return emulator.start(port);
+  });
+
+  // Stop emulator, so it could be restarted
+  afterEach(async () => {
+    return emulator.stop();
+  });
+
+  test("deploy basic contract - to service account", async () => {
+    const name = "HelloWorld";
+    await deployContractByName({ name });
+    const address = await getContractAddress(name);
+    const serviceAccount = await getServiceAddress();
+    expect(address).toBe(serviceAccount);
+  });
+
+  test("deploy basic contract - to service account, short notation", async () => {
+    const name = "HelloWorld";
+    await deployContractByName(name);
+    const address = await getContractAddress(name);
+    const serviceAccount = await getServiceAddress();
+    expect(address).toBe(serviceAccount);
+  });
+
+  test("deploy basic contract - to Alice account", async () => {
+    const Alice = await getAccountAddress("Alice");
+    const name = "HelloWorld";
+    await deployContractByName({ name, to: Alice });
+    const address = await getContractAddress(name);
+    expect(address).toBe(Alice);
+  });
+
+  test("deploy basic contract - to Alice account, short notation", async () => {
+    const name = "HelloWorld";
+    const Alice = await getAccountAddress("Alice");
+    await deployContractByName(name, Alice);
+    const address = await getContractAddress(name);
+    expect(address).toBe(Alice);
+  });
+});

dev-test/imports.test.js

@@ -1,7 +1,6 @@
 import path from "path";
-import { emulator, init, deployContract, resolveImports, getAccountAddress } from "../src";
+import { emulator, init, deployContract, resolveImports, getServiceAddress } from "../src";
 import { defaultsByName } from "../src/file";
-import { getServiceAddress } from "../src/manager";
 
 jest.setTimeout(10000);
 

dev-test/interaction.test.js

@@ -5,6 +5,7 @@ import {
   init,
   sendTransaction,
   executeScript,
+  getAccountAddress,
   shallResolve,
   shallThrow,
   shallPass,
@@ -19,7 +20,7 @@ describe("interactions - sendTransaction", () => {
     const basePath = path.resolve(__dirname, "./cadence");
     const port = 8080;
     await init(basePath, { port });
-    return emulator.start(port, false);
+    return emulator.start(port);
   });
 
   // Stop emulator, so it could be restarted
@@ -102,7 +103,34 @@ describe("interactions - sendTransaction", () => {
       return sendTransaction({ code, args });
     });
   });
+
+  test("sendTransaction - short notation, no signers", async () => {
+    emulator.setLogging(true);
+    await shallPass(async () => {
+      return sendTransaction("log-signer-address");
+    });
+  });
+
+  test("sendTransaction - short notation, Alice signed", async () => {
+    emulator.setLogging(true);
+    await shallPass(async () => {
+      const Alice = await getAccountAddress("Alice");
+      const signers = [Alice];
+      return sendTransaction("log-signer-address", signers);
+    });
+  });
+
+  test("sendTransaction - short notation, Alice signed, with args", async () => {
+    emulator.setLogging(true);
+    await shallPass(async () => {
+      const args = ["Hello, from Cadence!"];
+      const Alice = await getAccountAddress("Alice");
+      const signers = [Alice];
+      return sendTransaction("log-message", signers, args);
+    });
+  });
 });
+
 describe("interactions - executeScript", () => {
   // Instantiate emulator and path to Cadence files
   beforeEach(async () => {
@@ -140,4 +168,18 @@ describe("interactions - executeScript", () => {
       return executeScript({ code });
     });
   });
+
+  test("executeScript - shall pass with short notation", async () => {
+    const result = await shallResolve(executeScript("log-message"));
+    expect(result).toBe(42);
+  });
+
+  test("executeScript - shall pass with short notation and arguments", async () => {
+    const message = "Hello, from Cadence!";
+    const result = await shallResolve(() => {
+      const args = [message];
+      return executeScript("log-passed-message", args);
+    });
+    expect(result).toBe(message);
+  });
 });

dev-test/metadata.test.js

@@ -0,0 +1,76 @@
+import path from "path";
+import { init, emulator, executeScript, shallResolve } from "../src";
+import { mapValuesToCode } from "flow-cadut";
+
+jest.setTimeout(10000);
+
+describe("metadata examples", () => {
+  beforeEach(async () => {
+    const basePath = path.resolve("./cadence");
+    const port = 8080;
+    await init(basePath, { port });
+    return emulator.start(port);
+  });
+
+  afterEach(async () => {
+    return emulator.stop();
+  });
+
+  test("simple dictionary - {String: String}", async () => {
+    const code = `
+      pub fun main(metadata: {String: String}): String{
+        return metadata["name"]!
+      }
+    `;
+    const name = "Cadence";
+    const args = [{ name }];
+    const result = await shallResolve(executeScript({ code, args }));
+    expect(result).toBe(name);
+  });
+
+  test("simple dictionary - {String: Int}", async () => {
+    const code = `
+      pub fun main(metadata: {String: Int}): Int{
+        return metadata["answer"]!
+      }
+    `;
+    const answer = 42;
+    const args = [{ answer }];
+    const result = await shallResolve(executeScript({ code, args }));
+    expect(result).toBe(answer);
+  });
+
+  test("simple array - [String]", async () => {
+    const code = `
+      pub fun main(list: [String]): String{
+        return list[0]
+      }
+    `;
+    const value = "test";
+    const args = [[value]];
+    const result = await shallResolve(executeScript({ code, args }));
+    expect(result).toBe(value);
+  });
+
+  test("nested arrays - [[Int]]", async () => {
+    const code = `
+      pub fun main(list: [[Int]], index: Int): Int {
+        log("this is log message we want to output")
+        log(list[0][0])
+        log(list[0][1])
+        log(list[0][2])
+        return list[0][index] 
+      }
+    `;
+    const value = [1, 3, 3, 7];
+    const index = 3;
+    const args = [[value], index];
+
+    try {
+      const result = await executeScript({ code, args });
+      expect(result).toBe(value[index]);
+    } catch (e) {
+      console.error(e);
+    }
+  });
+});

dev-test/usage.test.js

@@ -10,7 +10,8 @@ import {
   getFlowBalance,
   shallRevert,
   shallResolve,
-  shallPass, shallThrow
+  shallPass,
+  shallThrow,
 } from "../src";
 
 // We need to set timeout for a higher number, because some transactions might take up some time
@@ -21,7 +22,7 @@ describe("Basic Usage test", () => {
   beforeEach(async () => {
     const basePath = path.resolve(__dirname, "./cadence");
     const port = 8080;
-    init(basePath, port);
+    await init(basePath, port);
     return emulator.start(port, false);
   });
 
@@ -59,7 +60,7 @@ describe("jest methods", () => {
       async () =>
         new Promise((_, reject) => {
           reject("something is wrong");
-        })
+        }),
     );
   });
 
@@ -69,7 +70,7 @@ describe("jest methods", () => {
       async () =>
         new Promise((resolve) => {
           resolve(ALL_GOOD);
-        })
+        }),
     );
     expect(result).toBe(ALL_GOOD);
   });
@@ -82,16 +83,16 @@ describe("jest methods", () => {
             status: 4,
             errorMessage: "",
           });
-        })
+        }),
     );
   });
 
   test("shall throw error", async () => {
     await shallThrow(
       async () =>
         new Promise(() => {
-          throw Error("didn't happen")
-        })
+          throw Error("didn't happen");
+        }),
     );
   });
 });

docs/generator.md

@@ -0,0 +1,38 @@
+---
+title: Bootstrap Framework
+sidebar_title: Bootstrap Framework
+description: How to quickly init testing environment
+---
+
+### Init Testing Environment
+
+Bootstrap your testing environment with a single command:
+
+```shell
+npx flow-js-testing init
+```
+
+When you run this command in the terminal it will initiate npm package in your current directory and create `package.json` file.
+Then it will install dependencies. After the installation is finished, the utility will create the required config files for Babel, Jest and Flow CLI.
+
+> ⚠️ **Warning:** This command will overwrite `babel.config.sj`, `jest.config.js` and `flow.json` files in the folder, where
+> it would be executed and also could affect your `package.json` file. That's why we advise you to use new empty folder
+> to contain your Cadence related tests.
+
+### Generate New Test Suit
+
+Create a test suit file for your project with all necessary imports and setup for describe blocks.
+You can start writing your asserts and expectations right away:
+
+```shell
+npx flow-js-testing make [name]
+```
+
+#### Flags
+
+| Name                  | Description                          |
+| --------------------- | ------------------------------------ |
+| `-c` or `--clear`     | Exclude comments from test suit code |
+| `-b` or `--base-path` | Specify base path to Cadence folder  |
+
+If you do not specify `name` as second argument, the tool will give your file a unique name.