public async Task SyncWithBlockchain_OperationSucceeds()
        {
            var transactionState = new GetTransactionStateResponse
            {
                TransactionState = TransactionState.Succeeded,
                OperationId      = Guid.NewGuid(),
                TransactionHash  = ValidTransactionHash
            };

            _executorClientMock.Setup(x => x.TransactionsApi.GetTransactionStateAsync(It.IsAny <string>()))
            .ReturnsAsync(transactionState);

            _operationRequestsRepositoryMock
            .Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
            .ReturnsAsync((IOperationRequest)null);

            _operationsRepositoryMock
            .Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
            .ReturnsAsync(new OperationEntity
            {
                Id              = transactionState.OperationId.Value,
                Status          = OperationStatus.Accepted,
                TransactionHash = transactionState.TransactionHash
            });

            _operationsRepositoryMock.Setup(x => x.SetStatusAsync
                                                (It.IsAny <Guid>(), It.IsAny <OperationStatus>(), It.IsAny <string>()))
            .Returns(Task.CompletedTask);

            var sut = CreateSutInstance();

            var result = await sut.SyncWithBlockchainAsync(ValidTransactionHash);

            Assert.Equal(OperationStatusUpdateError.None, result.Error);
        }
Exemplo n.º 2
0
        public async Task <GetTransactionStateResponse> GetTransactionStateAsync(
            string txHash)
        {
            var getTransactionState = _transactionService.TryGetTransactionStateAsync(txHash);
            var getOperationId      = _transactionService.TryGetOperationIdAsync(txHash);

            await Task.WhenAll(getTransactionState, getOperationId);

            var transactionState = getTransactionState.Result;
            var operationId      = getOperationId.Result;

            var response = new GetTransactionStateResponse
            {
                OperationId     = operationId,
                TransactionHash = txHash
            };

            if (transactionState != null)
            {
                switch (transactionState)
                {
                case DomainTransactionState.Pending:
                    response.TransactionState = ClientTransactionState.Pending;
                    break;

                case DomainTransactionState.Succeeded:
                    response.TransactionState = ClientTransactionState.Succeeded;
                    break;

                case DomainTransactionState.Failed:
                    response.TransactionState = ClientTransactionState.Failed;
                    break;

                default:
                    throw new ArgumentOutOfRangeException($"Transaction state [{transactionState}] is not supported.");
                }
            }
            else
            {
                response.Error = GetTransactionStateError.TransactionNotFound;
            }

            return(response);
        }