FLIP Fest - Merge PR (#63)

* Code submission for FLIP fest 'JS Testing Feature: Multiple return values from interaction 30' (#57)

* squash merge of TeamExponential work for flip 30

* add fixes to final submission requested by Max

* add remaining fixes for Max feedback

* get basic fixes done requested by Max

* update all usage of args for sendTransaction to allow flow-cadut to to resolve types

* update all points where executeScript is used to make sure args used correctly, allowing flow-cadut to resolve

* remove fcl/types

* revert package-lock.json to master plus package.json changes after running `npm install`

* revert ports in tests back to 8080, remove testMatch for 'dev-test' in package.json

* squash merge of latest changes per Max feedback

* make package.json flow-cadut match recent release from Max

* revert package-lock.json to master verion

* update version in package.json to match Max release, run npm install to update package-lock

* ran npm install

* squash merge latest updates/fixes

* replace package-lock.json

* revert package-lock.json

* remove try catch from tests

* remove onflow/types

* remove space

* prettify

* update cadut to release version

* add fix to generated code to mitigate error running tests

* ran prettify

* re-add 'limit' prop and usage in interaction.js

Co-authored-by: justjoolz <[email protected]>
Co-authored-by: Maksim Daunarovich <[email protected]>

* Bump version to next major release

* Add release notes with breaking changes.

Co-authored-by: Matt Chana <[email protected]>
Co-authored-by: justjoolz <[email protected]>

Author: 3 people

.gitignore

@@ -3,3 +3,4 @@
 .history
 node_modules
 dist
+.DS_Store

CHANGELOG.md

@@ -1,9 +1,40 @@
+### 0.2.0
+
+#### **BREAKING CHANGES**
+- `sendTransaction` and `executeScript` functions now return a tuple of [result, error]. As do the following functions:
+  - updateContract
+  - setBlockOffset
+  - scratch
+  - registerContract
+  - mintTokens
+  - initManager
+  - deployContract
+  - createAccount
+  - setBlockOffset
+  - mintFlow
+
+  - getManagerAddress
+  - getContractAddress
+  - getBlockOffset
+  - getBalance
+  - getAccountAddress
+  - checkManager
+  - getBlockOffset
+  - getFlowBalance
+
+
+Any code that relies upon checking the result of any of these functions and expects only the result returned will need to be refactored.
+Jest asserts were updated accordingly, but if you were writing your own you will need to update them.
+For examples of new usage see the [script](/docs/exeute-scripts.md), [transaction](/docs/send-transactions.md) and [api](/docs/api.md) documentation.
+
 ### 0.1.15
+
 - `limit` field added to script and transactions
 - `flow-cadut` brings several improvements and fixes to parser
 
 ### 0.1.14 - 2021-09-08
-- Refactor FlowManager to include new block offset  code
+
+- Refactor FlowManager to include new block offset code
 - Add code transformers functionality
 - Add block offset functionality
 - Add runnable examples
@@ -15,3 +46,4 @@
 - 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`
+

dev-test/deploy.test.js

@@ -5,7 +5,7 @@ import {
   deployContractByName,
   getContractAddress,
   getAccountAddress,
-  getServiceAddress,
+  getServiceAddress
 } from "../src";
 
 // We need to set timeout for a higher number, cause some transactions might take up some time
@@ -28,15 +28,15 @@ describe("interactions - sendTransaction", () => {
   test("deploy basic contract - to service account", async () => {
     const name = "HelloWorld";
     await deployContractByName({ name });
-    const address = await getContractAddress(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 [ address ] = await getContractAddress(name);
     const serviceAccount = await getServiceAddress();
     expect(address).toBe(serviceAccount);
   });
@@ -45,15 +45,15 @@ describe("interactions - sendTransaction", () => {
     const Alice = await getAccountAddress("Alice");
     const name = "HelloWorld";
     await deployContractByName({ name, to: Alice });
-    const address = await getContractAddress(name);
+    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);
+    const [ address ] = await getContractAddress(name);
     expect(address).toBe(Alice);
   });
 });

dev-test/imports.test.js

@@ -40,8 +40,10 @@ describe("import resolver", () => {
 
     const addressMap = await resolveImports(code);
     const Registry = await getServiceAddress();
-    expect(addressMap["First"]).toBe(Registry);
-    expect(addressMap["Second"]).toBe(Registry);
+    const [first] = addressMap["First"];
+    const [second] = addressMap["Second"];
+    expect(first).toBe(Registry);
+    expect(second).toBe(Registry);
     expect(addressMap["FungibleToken"]).toBe(defaultsByName.FungibleToken);
     expect(addressMap["FlowToken"]).toBe(defaultsByName.FlowToken);
   });

dev-test/interaction.test.js

@@ -1,5 +1,4 @@
 import path from "path";
-import * as types from "@onflow/types";
 import {
   emulator,
   init,
@@ -69,10 +68,11 @@ describe("interactions - sendTransaction", () => {
           }
         }
       `;
-      const args = [[42, types.Int]];
+      const args = [42];
       return sendTransaction({ code, args });
     });
   });
+
   test("sendTransaction - argument mapper - multiple", async () => {
     await shallPass(async () => {
       const code = `
@@ -82,13 +82,11 @@ describe("interactions - sendTransaction", () => {
           }
         }
       `;
-      const args = [
-        [42, 1337, types.Int],
-        ["Hello, Cadence", types.String],
-      ];
+      const args = [42, 1337, "Hello, Cadence"];
       return sendTransaction({ code, args });
     });
   });
+
   test("sendTransaction - argument mapper - automatic", async () => {
     await shallPass(async () => {
       const code = `
@@ -99,7 +97,6 @@ describe("interactions - sendTransaction", () => {
         }
       `;
       const args = [42, 1337, "Hello, Cadence"];
-
       return sendTransaction({ code, args });
     });
   });
@@ -170,13 +167,13 @@ describe("interactions - executeScript", () => {
   });
 
   test("executeScript - shall pass with short notation", async () => {
-    const result = await shallResolve(executeScript("log-message"));
+    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 [result] = await shallResolve(() => {
       const args = [message];
       return executeScript("log-passed-message", args);
     });

dev-test/metadata.test.js

@@ -23,7 +23,7 @@ describe("metadata examples", () => {
     `;
     const name = "Cadence";
     const args = [{ name }];
-    const result = await shallResolve(executeScript({ code, args }));
+    const [result] = await shallResolve(executeScript({ code, args }));
     expect(result).toBe(name);
   });
 
@@ -35,7 +35,7 @@ describe("metadata examples", () => {
     `;
     const answer = 42;
     const args = [{ answer }];
-    const result = await shallResolve(executeScript({ code, args }));
+    const [result] = await shallResolve(executeScript({ code, args }));
     expect(result).toBe(answer);
   });
 
@@ -47,7 +47,7 @@ describe("metadata examples", () => {
     `;
     const value = "test";
     const args = [[value]];
-    const result = await shallResolve(executeScript({ code, args }));
+    const [result] = await shallResolve(executeScript({ code, args }));
     expect(result).toBe(value);
   });
 
@@ -65,11 +65,8 @@ describe("metadata examples", () => {
     const index = 3;
     const args = [[value], index];
 
-    try {
-      const result = await executeScript({ code, args });
-      expect(result).toBe(value[index]);
-    } catch (e) {
-      console.error(e);
-    }
+    const [result, err] = await executeScript({ code, args });
+    expect(result).toBe(value[index]);
+    expect(err).toBe(null);
   });
 });

dev-test/usage.test.js

@@ -43,7 +43,7 @@ describe("Basic Usage test", () => {
     const addressMap = { HelloWorld: Alice };
     const code = await getScriptCode({ name: "get-message", addressMap });
     console.log({ code });
-    const message = await executeScript({
+    const [message] = await executeScript({
       code,
     });
     console.log({ message });

dev-test/utilities.test.js

@@ -35,18 +35,18 @@ describe("block height offset", () => {
   });
 
   it("should return zero offset", async () => {
-    const result = await executeScript("get-block-offset");
-    expect(result).toBe(0);
+    const [zeroOffset] = await executeScript("get-block-offset");
+    expect(zeroOffset).toBe(0);
   });
 
   it("should update offset", async () => {
     const manager = await getServiceAddress();
-    const result = await executeScript("get-block-offset");
-    expect(result).toBe(0);
+    const [zeroOffset] = await executeScript("get-block-offset");
+    expect(zeroOffset).toBe(0);
 
     const offset = 42;
     await shallPass(sendTransaction("set-block-offset", [manager], [offset]));
-    const newOffset = await executeScript("get-block-offset");
+    const [newOffset] = await executeScript("get-block-offset");
     expect(newOffset).toBe(offset);
   });
 
@@ -56,9 +56,10 @@ describe("block height offset", () => {
     const FlowManager = await getManagerAddress();
     const addressMap = { FlowManager };
 
-    const result = await getBlockOffset({ addressMap });
+    const [offSet] = await getBlockOffset({ addressMap });
+
+    expect(offSet).toBe(0);
 
-    expect(result).toBe(0);
   });
 
   it("should update offset with utility method", async () => {
@@ -67,15 +68,17 @@ describe("block height offset", () => {
     const FlowManager = await getManagerAddress();
     const addressMap = { FlowManager };
 
-    const oldOffset = await getBlockOffset({ addressMap });
+    const [oldOffset] = await getBlockOffset({ addressMap });
+
     expect(oldOffset).toBe(0);
 
     const offset = 42;
 
-    const txResult = await setBlockOffset(offset);
+    const [txResult] = await setBlockOffset(offset);
     expect(txResult.errorMessage).toBe("");
 
-    const newOffset = await getBlockOffset({ addressMap });
+    const [newOffset] = await getBlockOffset({ addressMap });
+
     expect(newOffset).toBe(offset);
   });
 });
@@ -95,18 +98,18 @@ describe("block height offset utilities", () => {
   });
 
   it("should return 0 for initial block offset", async () => {
-    const result = await shallResolve(manager.getBlockOffset());
-    expect(result).toBe(0);
+    const [initialOffset] = await shallResolve(manager.getBlockOffset());
+    expect(initialOffset).toBe(0);
   });
 
   it("should update block offset", async () => {
-    const initialOffset = await shallResolve(manager.getBlockOffset());
-    expect(initialOffset).toBe(0);
+    const [offset] = await shallResolve(manager.getBlockOffset());
+    expect(offset).toBe(0);
 
     const blockOffset = 42;
     await shallPass(manager.setBlockOffset(blockOffset));
 
-    const newOffset = await shallResolve(manager.getBlockOffset());
+    const [newOffset] = await shallResolve(manager.getBlockOffset());
     expect(newOffset).toBe(blockOffset);
   });
 });
@@ -126,15 +129,15 @@ describe("dev tests", () => {
   });
 
   it("should return proper offset", async () => {
-    const zeroOffset = await executeScript("get-block-offset");
+    const [zeroOffset] = await executeScript("get-block-offset");
     expect(zeroOffset).toBe(0);
   });
 
   it("should return proper offset, when changed", async () => {
     const offset = 42;
     const manager = await getServiceAddress();
     await shallPass(sendTransaction("set-block-offset", [manager], [offset]));
-    const newOffset = await executeScript("get-block-offset");
+    const [newOffset] = await executeScript("get-block-offset");
     expect(newOffset).toBe(offset);
   });
 
@@ -153,7 +156,7 @@ describe("dev tests", () => {
 
     const playgroundAddresses = ["0x01", "0x02", "0x03", "0x04", "0x05"];
     for (const i in playgroundAddresses) {
-      const result = await executeScript({
+      const [result] = await executeScript({
         code,
         transformers: [playgroundImport(accounts)],
         args: [playgroundAddresses[i]],