Use new near-mock-vm (#24)

* Remove Compiler warnings for null checks and cleaned up a little
* switched to use near-mock-vm and added tests to nearcore tests
* Update config to use strings for u128 and update outcome as class
* Transition to decorator support and simplify
* implement PersistentSet with tests

* update nearcore-tests
- removed config arg from cli
- will return to this after updated near-vm-runtime-runner is released

Co-authored-by: Sherif Abushadi <[email protected]>

Author: Willem Wyndham

.gitpod.yml

@@ -18,7 +18,7 @@ github:
     # add a "Review in Gitpod" button to the pull request's description (defaults to false)
     addBadge: false
     # add a label once the prebuild is ready to pull requests (defaults to false)
-    addLabel: false
+    addLabel: true
 
 # List the start up tasks. You can start them in parallel in multiple terminals. See https://www.gitpod.io/docs/config-start-tasks/
 tasks:

.npmignore

@@ -3,3 +3,7 @@ tsconfig.json
 nearcore-tests/
 assembly/__tests__
 **/*/out/
+bindgen/src
+bindgen/out
+bindgen/asconfig.js
+bindgen/test.js

assembly/__tests__/bindgen/main.ts

@@ -1,4 +1,3 @@
-//@nearfile
 // These imports need to be copied properly
 import { storage, context, ContractPromise, logging } from "../..";
 import { FooBar, ContainerClass, AnotherContainerClass, PromiseArgs, MyCallbackResult, MyContractPromiseResult } from "./model";

assembly/__tests__/bindgen/model.ts

@@ -1,8 +1,8 @@
 
-// @nearfile
 
 import { u128 } from "../..";
 
+@nearBindgen
 export class FooBar {
     foo: i32 = 0;
     bar: u32 = 1;
@@ -21,20 +21,24 @@ export class FooBar {
     u64Arr: u64[];
 }
 
+@nearBindgen
 export class Nullables {
     str: string;
     u128: u128;
     uint8Array: Uint8Array;
 }
 
+@nearBindgen
 export class ContainerClass {
     foobar: FooBar
 }
 
+@nearBindgen
 export class AnotherContainerClass {
     foobars: Array<Array<FooBar>>
 }
 
+@nearBindgen
 export class PromiseArgs {
     receiver: string;
     methodName: string;
@@ -45,16 +49,19 @@ export class PromiseArgs {
     callbackBalance: i32;
 }
 
+@nearBindgen
 export class MyContractPromiseResult {
     ok: bool;
     r: MyCallbackResult;
 }
 
+@nearBindgen
 export class MyCallbackResult {
     rs: MyContractPromiseResult[];
     n: string;
 }
 
+@nearBindgen
 export class Generic<T> {
     value: T;
 }

assembly/__tests__/contract.spec.ts

@@ -3,33 +3,6 @@ import { Contract } from "./contract";
 import { VM } from "../vm";
 
 describe("Contract", () => {
-  beforeAll(() => {
-    VM.saveState();
-  });
-  
-  afterAll(() => {
-    VM.restoreState();
-  });
-
-  it("should be able to be stored and retrieved", () => {
-    const contract = new Contract("unique name!");
-    storage.set("contract", contract);
-    const otherContract = storage.get<Contract>("contract")!;
-    expect(contract.name).toBe(otherContract.name, "contracts should have the same name");
-    expect(contract.name).not.toBe("", "contract's name should not be empty");
-  });
-  
-  it("should still be in the storage", () => {
-    const otherContract = storage.get<Contract>("contract")!;
-    expect(otherContract.name).toBe("unique name!", "contracts should have the same name");
-    expect(otherContract.name).not.toBe("", "contract's name should not be empty");
-  });
-});
-
-describe("Contract", () => {
-  beforeEach( () => {
-    VM.saveState();
-  });
 
   afterEach(() => {
     VM.restoreState();

assembly/__tests__/contract.ts

@@ -1,5 +1,5 @@
-//@nearfile
 
+@nearBindgen
 export class Contract {
   constructor(public name: string) {}
 }

assembly/__tests__/model.ts

@@ -1,5 +1,6 @@
-//@nearfile
+
 // Exporting a new class TextMessage so it can be used outside of this file.
+@nearBindgen
 export class TextMessage {
   sender: string;
   text: string;

assembly/__tests__/runtime/generic.ts

@@ -1,5 +1,6 @@
 //@nearfile
 
+@nearBindgen
 export class Box<T> {
   t: T;
 }

assembly/__tests__/runtime/main.ts

@@ -1,4 +1,3 @@
-//@nearfile
 import { u128, context, storage, logging, base58, base64, PersistentMap, PersistentVector, PersistentDeque, ContractPromise, math } from "../..";
 import { TextMessage } from "./model";
 import { _testTextMessage, _testTextMessageTwo, _testBytes, _testBytesTwo } from "./util";

assembly/__tests__/runtime/model.ts

@@ -1,5 +1,5 @@
-//@nearfile
 // Exporting a new class TextMessage so it can be used outside of this file.
+@nearBindgen
 export class TextMessage {
   sender: string;
   text: string;

assembly/__tests__/runtime/persistent-set.spec.ts

@@ -0,0 +1,78 @@
+import { PersistentSet } from "../../runtime";
+
+let set: PersistentSet<string>
+const item = "hello"
+
+function addItem(_item: string = item): void {
+  set.add(_item)
+}
+
+describe("Sets should handle", () => {
+
+  beforeEach(() => {
+    set = new PersistentSet<string>("set1");
+  })
+
+  it("supports adding items", () => {
+    addItem()
+    expect(set.has(item)).toBeTruthy("The set should have the item")
+  })
+
+  it("checks for items", () => {
+    expect(set.has(item)).toBeFalsy("The set should not have the item")
+  })
+
+  throws("if attempting to delete a non-existent item", () => {
+    set.delete(item)
+  })
+
+  it("can be cleared", () => {
+    addItem()
+    expect(set.size).toBe(1)
+    set.clear()
+    expect(set.size).toBe(0)
+  })
+
+  it("only allows items to be added once", () => {
+    addItem()
+    addItem()
+    addItem()
+    expect(set.size).toBe(1)
+  })
+
+  it("allows multiple items to be added", () => {
+    addItem("hello")
+    addItem("world")
+    expect(set.size).toBe(2)
+  })
+
+  it("deleting items", () => {
+    addItem()
+    expect(set.has(item)).toBeTruthy("The item should be found first")
+    set.delete(item)
+    expect(set.has(item)).toBeFalsy("The item should be deleted")
+  });
+
+  it("returns a list of values as an array", () => {
+    addItem("one")
+    addItem("two")
+    addItem("three")
+
+    expect(set.values()).toStrictEqual(["one", "two", "three"])
+  })
+
+  it("returns a list of values out of order after delete", () => {
+    addItem("one")
+    addItem("two")
+    addItem("three")
+    addItem("four")
+
+    set.delete("two")
+
+    let values = set.values()
+    expect(values).not.toInclude("two")
+    expect(values).toStrictEqual(["one", "four", "three"])
+  })
+
+
+})