public IEnumerator CallsMustWaitForOtherCallToComplete() { // If multiple calls are made at the same time, only one should be actually communicating // with the backend at a given moment, others must wait for completion return(AsyncEditorTestUtility.AsyncTest(async() => { byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); EvmContract contract = await ContractTestUtility.GetEvmContract(privateKey, publicKey, this.testsAbi); using (contract.Client) { const int callCount = 10; List <int> callEndOrderList = new List <int>(); Task[] callTasks = new Task[callCount]; for (int i = 0; i < callTasks.Length; i++) { int iCopy = i; Func <Task> taskFunc = async() => { Debug.Log($"Call {iCopy}: Start"); await contract.CallAsync("setTestUint", new BigInteger(iCopy)); Debug.Log($"Call {iCopy}: End"); callEndOrderList.Add(iCopy); }; callTasks[i] = taskFunc(); } await Task.WhenAll(callTasks); Assert.AreEqual(callCount, callEndOrderList.Count); Assert.AreEqual(callEndOrderList.OrderBy(i => i).ToList(), callEndOrderList); } }, timeout: 25000)); }
public IEnumerator InvalidTxNonceExceptionTest() { return(AsyncEditorTestUtility.AsyncTest(async() => { byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); EvmContract invalidNonceContract = await ContractTestUtility.GetEvmContract( privateKey, publicKey, this.testContext.TestsAbi, (client, _, __) => new ITxMiddlewareHandler[] { new ControllableNonceTxMiddleware(publicKey, client) { ForcedNextNonce = UInt64.MaxValue }, new SignedTxMiddleware(privateKey) }); try { await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); } catch (InvalidTxNonceException e) { Assert.Catch <InvalidTxNonceException>(() => { throw e; }); } }, timeout: 35000)); }
public IEnumerator MultipleSimultaneousRpcCallsMustSucceedTest() { return(AsyncEditorTestUtility.AsyncTest(async() => { byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); EvmContract contract = await ContractTestUtility.GetEvmContract(privateKey, publicKey, this.testsAbi); using (contract.Client) { const int callCount = 20; Task[] callTasks = new Task[callCount]; for (int i = 0; i < callTasks.Length; i++) { // Any request will do. Use the nonce request, simple it is a simple one callTasks[i] = new Task <ulong>(() => contract.Client.GetNonceAsync(CryptoUtils.BytesToHexString(publicKey)).Result); } foreach (Task task in callTasks) { task.Start(); } await Task.WhenAll(callTasks); } })); }
private async Task EnsureContract() { if (this.contract != null) { return; } byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); this.contract = await ContractTestUtility.GetEvmContract(privateKey, publicKey, this.testsAbi); }
public async Task EnsureContract() { if (this.Contract != null) { this.Contract?.Client?.Dispose(); this.Contract = null; } byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); this.Contract = await ContractTestUtility.GetEvmContract(privateKey, publicKey, this.TestsAbi); }
public IEnumerator TxAlreadyExistsInCacheRecoverTest() { return(AsyncEditorTestUtility.AsyncTest(async() => { byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); int callCounter = 0; EvmContract invalidNonceContract = await ContractTestUtility.GetEvmContract( privateKey, publicKey, this.testContext.TestsAbi, (client, _, __) => { ControllableNonceTxMiddleware controllableNonceTxMiddleware = new ControllableNonceTxMiddleware(publicKey, client); controllableNonceTxMiddleware.GetNextNonceAsyncCalled += nextNonce => { switch (callCounter) { case 0: Assert.AreEqual(1, nextNonce); controllableNonceTxMiddleware.ForcedNextNonce = 1; break; case 1: Assert.AreEqual(1, nextNonce); controllableNonceTxMiddleware.ForcedNextNonce = null; break; case 2: Assert.AreEqual(2, nextNonce); break; default: Assert.Fail($"Unexpected call #{callCounter}"); break; } callCounter++; }; return new ITxMiddlewareHandler[] { controllableNonceTxMiddleware, new SignedTxMiddleware(privateKey) }; }); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); }, timeout: 20000)); }
public IEnumerator SpeculativeNextNonceTest() { return(AsyncEditorTestUtility.AsyncTest(async() => { byte[] privateKey = CryptoUtils.GeneratePrivateKey(); byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey); int callCounter = 0; EvmContract invalidNonceContract = await ContractTestUtility.GetEvmContract( privateKey, publicKey, this.testContext.TestsAbi, (client, _, __) => { ControllableNonceTxMiddleware controllableNonceTxMiddleware = new ControllableNonceTxMiddleware(publicKey, client); controllableNonceTxMiddleware.GetNextNonceAsyncCalled += nextNonce => { switch (callCounter) { case 0: Assert.AreEqual(1, nextNonce); controllableNonceTxMiddleware.FailOnGetNonceFromNode = true; break; case 1: Assert.AreEqual(2, nextNonce); break; case 2: Assert.AreEqual(3, nextNonce); controllableNonceTxMiddleware.FailOnGetNonceFromNode = false; controllableNonceTxMiddleware.ForcedNextNonce = UInt64.MaxValue; break; case 3: Assert.AreEqual(UInt64.MaxValue, nextNonce); break; case 4: Assert.AreEqual(UInt64.MaxValue, nextNonce); break; case 5: Assert.AreEqual(UInt64.MaxValue, nextNonce); controllableNonceTxMiddleware.ForcedNextNonce = null; break; case 6: Assert.AreEqual(4, nextNonce); break; case 7: Assert.AreEqual(5, nextNonce); break; default: Assert.Fail($"Unexpected call #{callCounter}"); break; } callCounter++; }; return new ITxMiddlewareHandler[] { controllableNonceTxMiddleware, new SignedTxMiddleware(privateKey) }; }); try { await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); await invalidNonceContract.CallAsync("setTestUint", new BigInteger(123456789)); Assert.AreEqual(8, callCounter); } catch (InvalidTxNonceException e) { Assert.Catch <InvalidTxNonceException>(() => { throw e; }); } }, timeout: 20000)); }