Refine API of the testing framework

These changes will allow testing providers to unify
unit & integration tests.

runtime/stdlib/contracts/test.cdc

@@ -27,6 +27,12 @@ pub contract Test {
             return self.backend.createAccount()
         }
 
+        /// Returns the account for the given address.
+        ///
+        pub fun getAccount(_ address: Address): Account {
+            return self.backend.getAccount(address)
+        }
+
         /// Add a transaction to the current block.
         ///
         pub fun addTransaction(_ tx: Transaction) {
@@ -77,14 +83,12 @@ pub contract Test {
         ///
         pub fun deployContract(
             name: String,
-            code: String,
-            account: Account,
+            path: String,
             arguments: [AnyStruct]
         ): Error? {
             return self.backend.deployContract(
                 name: name,
-                code: code,
-                account: account,
+                path: path,
                 arguments: arguments
             )
         }
@@ -297,6 +301,10 @@ pub contract Test {
         ///
         pub fun createAccount(): Account
 
+        /// Returns the account for the given address.
+        ///
+        pub fun getAccount(_ address: Address): Account
+
         /// Add a transaction to the current block.
         ///
         pub fun addTransaction(_ tx: Transaction)
@@ -315,8 +323,7 @@ pub contract Test {
         ///
         pub fun deployContract(
             name: String,
-            code: String,
-            account: Account,
+            path: String,
             arguments: [AnyStruct]
         ): Error?
 

runtime/stdlib/test-framework.go

@@ -43,6 +43,8 @@ type Blockchain interface {
 
 	CreateAccount() (*Account, error)
 
+	GetAccount(interpreter.AddressValue) (*Account, error)
+
 	AddTransaction(
 		inter *interpreter.Interpreter,
 		code string,
@@ -58,8 +60,7 @@ type Blockchain interface {
 	DeployContract(
 		inter *interpreter.Interpreter,
 		name string,
-		code string,
-		account *Account,
+		path string,
 		arguments []interpreter.Value,
 	) error
 

runtime/stdlib/test_contract.go

@@ -48,6 +48,14 @@ type TestContractType struct {
 	expectFailureFunction             interpreter.FunctionValue
 }
 
+// 'Test.blockchain' public field
+
+const testTypeBlockchainFieldName = "blockchain"
+
+const testTypeBlockchainFieldDocString = `
+An emulator-backed blockchain.
+`
+
 // 'Test.assert' function
 
 const testTypeAssertFunctionDocString = `
@@ -1072,6 +1080,16 @@ func newTestContractType() *TestContractType {
 
 	blockchainType := ty.blockchainType()
 
+	compositeType.Fields = []string{testTypeBlockchainFieldName}
+	blockchainField := sema.NewPublicConstantFieldMember(
+		nil,
+		compositeType,
+		testTypeBlockchainFieldName,
+		blockchainType,
+		testTypeBlockchainFieldDocString,
+	)
+	compositeType.Members.Set(testTypeBlockchainFieldName, blockchainField)
+
 	// Test.assert()
 	compositeType.Members.Set(
 		testTypeAssertFunctionName,
@@ -1368,5 +1386,35 @@ func (t *TestContractType) NewTestContract(
 	compositeValue.Functions[testTypeBeLessThanFunctionName] = t.beLessThanFunction
 	compositeValue.Functions[testExpectFailureFunctionName] = t.expectFailureFunction
 
+	// Create an `EmulatorBackend`
+	emulatorBackend := t.emulatorBackendType.newEmulatorBackend(
+		inter,
+		testFramework.NewEmulatorBackend(),
+		interpreter.EmptyLocationRange,
+	)
+
+	// Create a 'Blockchain' struct value, that wraps the emulator backend,
+	// by calling the constructor of 'Blockchain'.
+	blockchainConstructor := getNestedTypeConstructorValue(
+		compositeValue,
+		testBlockchainTypeName,
+	)
+	blockchain, err := inter.InvokeExternally(
+		blockchainConstructor,
+		blockchainConstructor.Type,
+		[]interpreter.Value{
+			emulatorBackend,
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+	compositeValue.SetMember(
+		inter,
+		interpreter.EmptyLocationRange,
+		testTypeBlockchainFieldName,
+		blockchain,
+	)
+
 	return compositeValue, nil
 }

runtime/stdlib/test_emulatorbackend.go

@@ -20,6 +20,8 @@
 package stdlib
 
 import (
+	"fmt"
+
 	"github.com/onflow/cadence/runtime/common"
 	"github.com/onflow/cadence/runtime/errors"
 	"github.com/onflow/cadence/runtime/interpreter"
@@ -49,6 +51,7 @@ type testEmulatorBackendType struct {
 	moveTimeFunctionType               *sema.FunctionType
 	createSnapshotFunctionType         *sema.FunctionType
 	loadSnapshotFunctionType           *sema.FunctionType
+	getAccountFunctionType             *sema.FunctionType
 }
 
 func newTestEmulatorBackendType(
@@ -124,6 +127,11 @@ func newTestEmulatorBackendType(
 		testEmulatorBackendTypeLoadSnapshotFunctionName,
 	)
 
+	getAccountFunctionType := interfaceFunctionType(
+		blockchainBackendInterfaceType,
+		testEmulatorBackendTypeGetAccountFunctionName,
+	)
+
 	compositeType := &sema.CompositeType{
 		Identifier: testEmulatorBackendTypeName,
 		Kind:       common.CompositeKindStructure,
@@ -218,6 +226,12 @@ func newTestEmulatorBackendType(
 			loadSnapshotFunctionType,
 			testEmulatorBackendTypeLoadSnapshotFunctionDocString,
 		),
+		sema.NewUnmeteredPublicFunctionMember(
+			compositeType,
+			testEmulatorBackendTypeGetAccountFunctionName,
+			getAccountFunctionType,
+			testEmulatorBackendTypeGetAccountFunctionDocString,
+		),
 	}
 
 	compositeType.Members = sema.MembersAsMap(members)
@@ -239,6 +253,7 @@ func newTestEmulatorBackendType(
 		moveTimeFunctionType:               moveTimeFunctionType,
 		createSnapshotFunctionType:         createSnapshotFunctionType,
 		loadSnapshotFunctionType:           loadSnapshotFunctionType,
+		getAccountFunctionType:             getAccountFunctionType,
 	}
 }
 
@@ -348,6 +363,47 @@ func newTestAccountValue(
 	return accountValue
 }
 
+// 'EmulatorBackend.getAccount' function
+
+const testEmulatorBackendTypeGetAccountFunctionName = "getAccount"
+
+const testEmulatorBackendTypeGetAccountFunctionDocString = `
+Returns the account for the given address.
+`
+
+func (t *testEmulatorBackendType) newGetAccountFunction(
+	blockchain Blockchain,
+) *interpreter.HostFunctionValue {
+	return interpreter.NewUnmeteredHostFunctionValue(
+		t.getAccountFunctionType,
+		func(invocation interpreter.Invocation) interpreter.Value {
+			address, ok := invocation.Arguments[0].(interpreter.AddressValue)
+			if !ok {
+				panic(errors.NewUnreachableError())
+			}
+
+			account, err := blockchain.GetAccount(address)
+			if err != nil {
+				msg := fmt.Sprintf("account with address: %s was not found", address)
+				panic(PanicError{
+					Message:       msg,
+					LocationRange: invocation.LocationRange,
+				})
+			}
+
+			inter := invocation.Interpreter
+			locationRange := invocation.LocationRange
+
+			return newTestAccountValue(
+				blockchain,
+				inter,
+				locationRange,
+				account,
+			)
+		},
+	)
+}
+
 // 'EmulatorBackend.addTransaction' function
 
 const testEmulatorBackendTypeAddTransactionFunctionName = "addTransaction"
@@ -509,31 +565,22 @@ func (t *testEmulatorBackendType) newDeployContractFunction(
 				panic(errors.NewUnreachableError())
 			}
 
-			// Contract code
-			code, ok := invocation.Arguments[1].(*interpreter.StringValue)
-			if !ok {
-				panic(errors.NewUnreachableError())
-			}
-
-			// authorizer
-			accountValue, ok := invocation.Arguments[2].(interpreter.MemberAccessibleValue)
+			// Contract file path
+			path, ok := invocation.Arguments[1].(*interpreter.StringValue)
 			if !ok {
 				panic(errors.NewUnreachableError())
 			}
 
-			account := accountFromValue(inter, accountValue, invocation.LocationRange)
-
 			// Contract init arguments
-			args, err := arrayValueToSlice(inter, invocation.Arguments[3])
+			args, err := arrayValueToSlice(inter, invocation.Arguments[2])
 			if err != nil {
 				panic(err)
 			}
 
 			err = blockchain.DeployContract(
 				inter,
 				name.Str,
-				code.Str,
-				account,
+				path.Str,
 				args,
 			)
 
@@ -878,6 +925,10 @@ func (t *testEmulatorBackendType) newEmulatorBackend(
 			Name:  testEmulatorBackendTypeLoadSnapshotFunctionName,
 			Value: t.newLoadSnapshotFunction(blockchain),
 		},
+		{
+			Name:  testEmulatorBackendTypeGetAccountFunctionName,
+			Value: t.newGetAccountFunction(blockchain),
+		},
 	}
 
 	// TODO: Use SimpleCompositeValue