public async Task MergeAddressAsync_Called__Wallets_Exists__Return_MergedAddress() { #region Responses var content1 = new MergedAddressResponse { Address = "address$memo" }; #endregion var handlerStub = new DelegatingHandlerStub((request, cancellationToken) => { var content = content1; var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(Task.FromResult(response)); }); var client = CreateClient(handlerStub); var result = await client.MergeAddressAsync("Stellar", "address", "memo"); Assert.True(result == content1.Address); }
public async Task Can_Return_Dummy_On_HttpException() { #region Responses var clientId = Guid.NewGuid(); var dummy = Guid.NewGuid(); var content1 = BlockchainWalletsErrorResponse.Create( "msg", ErrorType.None); #endregion var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { var content = content1; var response = new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(response); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(5)); var result = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummy); Assert.Equal(dummy, result); }
public async Task MergeAddressAsync_Called__With_Not_Valid_Args__Throw_Exception() { #region Responses var content1 = BlockchainWalletsErrorResponse.Create( $"Address extension is not supported for specified blockchain type ", ErrorType.None); #endregion var handlerStub = new DelegatingHandlerStub((request, cancellationToken) => { var content = content1; var response = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(Task.FromResult(response)); }); var client = CreateClient(handlerStub); await Assert.ThrowsAsync <ErrorResponseException>(async() => { var result = await client.MergeAddressAsync("Stellar", "address", "memo"); }); }
public async Task Throws_Exception_On_Timeout() { #region Responses var content1 = BlockchainWalletsErrorResponse.Create( $"Address extension is not supported for specified blockchain type ", ErrorType.None); #endregion var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken); var content = content1; var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(response); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(5)); await Assert.ThrowsAnyAsync <Exception>(async() => { await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), timeout: TimeSpan.FromSeconds(1)); }); }
public async Task Сan_Return_Result_On_Failure_Handler( ) { #region Responses var clientId = Guid.NewGuid(); var content1 = new ClientIdResponse { ClientId = clientId }; #endregion var handlerStub = new DelegatingHandlerStub((request, cancellationToken) => { var content = content1; var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(Task.FromResult(response)); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(5)); var result = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), timeout : TimeSpan.FromSeconds(60)); Assert.Equal(clientId, result); }
public async Task CreateWalletAsync_Called__Wallet_Exists__Throws_Duplicate_Exception() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.Conflict, new BlockchainWalletsErrorResponse()); var client = CreateClient(handlerStub); await Assert.ThrowsAsync <DuplicationWalletException>(() => client.CreateWalletAsync("EthereumClassic", "ETC", Guid.NewGuid())); }
public async Task Can_Return_Dummy_On_Timeout() { #region Responses var clientId = Guid.NewGuid(); var dummy = Guid.NewGuid(); var content1 = new ClientIdResponse { ClientId = clientId }; #endregion var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { await Task.Delay(TimeSpan.FromMilliseconds(500), cancellationToken); var content = content1; var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(response); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(5)); var result = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), timeout : TimeSpan.FromMilliseconds(100), fallbackResult : () => dummy); Assert.Equal(dummy, result); }
public async Task Throws_Exception_On_Http_Error() { #region Responses var clientId = Guid.NewGuid(); var content1 = new ClientIdResponse { ClientId = clientId }; #endregion var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken); var content = content1; var response = new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(response); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(5)); await Assert.ThrowsAnyAsync <Exception>(async() => { await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address")); }); }
public async Task DeleteWalletAsync_Called__Wallet_Exists__False_Returned() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.NotFound, new BlockchainWalletsErrorResponse()); var client = CreateClient(handlerStub); var response = await client.DeleteWalletAsync("EthereumClassic", "ETC", Guid.NewGuid()); Assert.False(response); }
public async Task DeleteWalletAsync_Called__Wallet_Exists__True_Returned() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.Accepted); var client = CreateClient(handlerStub); var response = await client.DeleteWalletAsync("EthereumClassic", "ETC", Guid.NewGuid()); Assert.True(response); }
public async Task GetIsAliveAsync_Called__ServiceIsHealthy_IsAliveResponse_Returned() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.OK, new IsAliveResponse()); var client = CreateClient(handlerStub); var response = await client.GetIsAliveAsync(); Assert.IsType <IsAliveResponse>(response); }
public async Task Breaks_Circuit_On_Timeout() { #region Responses var dummyResult = Guid.NewGuid(); var actualResult = Guid.NewGuid(); var content1 = new ClientIdResponse { ClientId = actualResult }; #endregion var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken); var content = content1; var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; return(response); }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromMinutes(10)); //call 1 - timeouts var st1 = new Stopwatch(); st1.Start(); var result1 = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummyResult, timeout : TimeSpan.FromSeconds(2)); st1.Stop(); Assert.True(st1.Elapsed >= TimeSpan.FromSeconds(2)); Assert.Equal(dummyResult, result1); //call 2 return result without timeout var st2 = new Stopwatch(); st2.Start(); var result2 = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummyResult, timeout : TimeSpan.FromSeconds(2)); st2.Stop(); Assert.Equal(dummyResult, result2); Assert.True(st2.Elapsed < TimeSpan.FromSeconds(2)); }
public async Task GetClientIdAsync_Called__Client_Exists__ClientId_Returned() { var clientId = Guid.NewGuid(); var handlerStub = new DelegatingHandlerStub(HttpStatusCode.OK, new ClientIdResponse { ClientId = clientId }); var client = CreateClient(handlerStub); var response = await client.GetClientIdAsync("EthereumClassic", "0x83f0726180cf3964b69f62ac063c5cb9a66b3be5"); Assert.Equal(clientId, response); }
public async Task DeleteWalletAsync_Called__Asset_Is_Not_Supported__Exception_Thrown() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.BadRequest, new BlockchainWalletsErrorResponse()); var client = CreateClient(handlerStub); try { await client.DeleteWalletAsync("EthereumClassic", "ETC", Guid.NewGuid()); } catch (Exception e) { Assert.IsType <ErrorResponseException>(e); } }
public async Task GetAddressAsync_Called__Client_Exists__Address_Returned() { const string address = "0x83f0726180cf3964b69f62ac063c5cb9a66b3be5"; var handlerStub = new DelegatingHandlerStub(HttpStatusCode.OK, new AddressResponse { Address = address }); var client = CreateClient(handlerStub); var response = await client.GetAddressAsync("EthereumClassic", "ETC", Guid.NewGuid()); Assert.Equal(address, response.Address); }
public async Task GetAddressAsync_Called__Client_Not_Exists__Exception_Thrown() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.NoContent); var client = CreateClient(handlerStub); try { await client.GetAddressAsync("EthereumClassic", "ETC", Guid.NewGuid()); } catch (Exception e) { Assert.IsType <ResultValidationException>(e); } }
public async Task GetClientIdAsync_Called__Client_Not_Exists__Exception_Thrown() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.NoContent); var client = CreateClient(handlerStub); try { await client.GetClientIdAsync("EthereumClassic", "0x83f0726180cf3964b69f62ac063c5cb9a66b3be5"); } catch (Exception e) { Assert.IsType <ResultValidationException>(e); } }
public async Task GetIsAliveAsync_Called__ServiceIsUnhealthy_Exception_Thrown() { var handlerStub = new DelegatingHandlerStub(HttpStatusCode.InternalServerError, BlockchainWalletsErrorResponse.Create("")); var client = CreateClient(handlerStub); try { await client.GetIsAliveAsync(); } catch (Exception e) { Assert.IsType <ErrorResponseException>(e); } }
public async Task GetClientWalletsAsync_Called__Wallets_Exists__Return_ClientWalletResponse() { var clientId = Guid.Parse("25c47ff8-e31e-4913-8e02-8c2512f0111e"); var handlerStub = new DelegatingHandlerStub(HttpStatusCode.OK, new WalletsResponse { ContinuationToken = null, Wallets = new[] { new WalletResponse { Address = "0x00000000...", ClientId = clientId, BlockchainType = "EthereumClassic", IntegrationLayerAssetId = "ETC" } } }); var client = CreateClient(handlerStub); var result = await client.TryGetWalletsAsync(clientId, 10, null); Assert.True(result?.Wallets.FirstOrDefault()?.ClientId == clientId); }
public async Task Any_Method_Called__Input_Parameters_Are_Invalid__Exception_Thrown() { var handlerStub = new DelegatingHandlerStub(); var client = CreateClient(handlerStub); var blockchainTypeCases = new[] { new { Case = (string)null, IsValid = false }, new { Case = "", IsValid = false }, new { Case = "EthereumClassic", IsValid = true } }; var integrationLayerAssetIdCases = new[] { new { Case = (string)null, IsValid = false }, new { Case = "", IsValid = false }, new { Case = "ETC", IsValid = true } }; var clientIdCases = new[] { new { Case = Guid.Empty, IsValid = false }, new { Case = Guid.NewGuid(), IsValid = true } }; var clientActions = new List <Func <string, string, Guid, Task> > { async(a, b, c) => { await client.CreateWalletAsync(a, b, c); }, async(a, b, c) => { await client.DeleteWalletAsync(a, b, c); }, async(a, b, c) => { await client.GetAddressAsync(a, b, c); }, async(a, b, c) => { await client.TryGetAddressAsync(a, b, c); } }; foreach (var clientAction in clientActions) { foreach (var blockchainTypeCase in blockchainTypeCases) { foreach (var integrationLayerAssetIdCase in integrationLayerAssetIdCases) { foreach (var clientIdCase in clientIdCases) { if (!blockchainTypeCase.IsValid && !integrationLayerAssetIdCase.IsValid && !clientIdCase.IsValid) { try { await clientAction ( integrationLayerAssetIdCase.Case, integrationLayerAssetIdCase.Case, clientIdCase.Case ); } catch (Exception e) { Assert.IsType <ArgumentException>(e); } } } } } } var addressActions = new List <Func <string, string, Task> > { async(a, b) => { await client.GetClientIdAsync(a, b); }, async(a, b) => { await client.TryGetClientIdAsync(a, b); } }; var addressCases = new[] { new { Case = (string)null, IsValid = false }, new { Case = "", IsValid = false }, new { Case = "0x83f0726180cf3964b69f62ac063c5cb9a66b3be5", IsValid = true } }; foreach (var addressAction in addressActions) { foreach (var blockchainTypeCase in blockchainTypeCases) { foreach (var addressCase in addressCases) { if (!blockchainTypeCase.IsValid && !addressCase.IsValid) { try { await addressAction ( blockchainTypeCase.Case, addressCase.Case ); } catch (Exception e) { Assert.IsType <ArgumentException>(e); } } } } } }
public async Task Can_Open_Circuit_On_First_Failure_And_Close_Circuit() { #region Responses var actualValue = Guid.NewGuid(); var dummy = Guid.NewGuid(); var content1 = BlockchainWalletsErrorResponse.Create( "msg", ErrorType.None); #endregion var counter = 0; var handlerStub = new DelegatingHandlerStub(async(request, cancellationToken) => { if (counter <= 1) { var content = content1; var response = new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; counter++; return(response); } else { var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(new ClientIdResponse { ClientId = actualValue })) }; return(response); } }); var client = CreateClient(handlerStub); var failureHandler = new BlockchainWalletsFailureHandler(durationOfBreak: TimeSpan.FromSeconds(1)); var result1 = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummy); Assert.Equal(dummy, result1); await Task.Delay(TimeSpan.FromMilliseconds(100)); //circuit is still open var result2 = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummy); Assert.Equal(dummy, result2); await Task.Delay(TimeSpan.FromMilliseconds(1100)); //circuit is closed var result3 = await failureHandler.Execute( () => client.TryGetClientIdAsync("blockchainType", "Address"), fallbackResult : () => dummy); Assert.Equal(actualValue, result3); }
public async Task GetClientWalletsAsync_Called__Wallets_Exists__Return_Many_ClientWalletResponse() { var clientId = Guid.Parse("25c47ff8-e31e-4913-8e02-8c2512f0111e"); var counter = 0; #region Responses var content1 = new WalletsResponse { ContinuationToken = "1", Wallets = new[] { new WalletResponse { Address = "0x00000000...", ClientId = clientId, BlockchainType = "EthereumClassic", IntegrationLayerAssetId = "ETC" } } }; var content2 = new WalletsResponse { ContinuationToken = null, Wallets = new[] { new WalletResponse { Address = "0x00000001...",//Does not matter ClientId = clientId, BlockchainType = "LiteCoin", IntegrationLayerAssetId = "LTC" } } }; #endregion var handlerStub = new DelegatingHandlerStub((request, cancellationToken) => { var content = content1; if (counter > 0) { content = content2; } var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(content)) }; counter++; return(Task.FromResult(response)); }); var client = CreateClient(handlerStub); var result = (await client.GetAllWalletsAsync(clientId, 1)).ToList(); // ReSharper disable PossibleMultipleEnumeration Assert.True(result.Count() == 2); Assert.True(result.FirstOrDefault()?.ClientId == clientId); // ReSharper restore PossibleMultipleEnumeration }