public Task PostAsync_NoAvailableAddress_ShouldServiceUnavailable() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(100), }; this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync((ReceivingAddressReservation)null); // Act. var result = await Subject.PostAsync(request, cancellationToken); // Assert. var status = Assert.IsType <StatusCodeResult>(result); Assert.Equal((int)HttpStatusCode.ServiceUnavailable, status.StatusCode); this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); })); }
public Task PostAsync_WithCallback_ShouldWatchWithCallback() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(1000), }; var callback = new Callback( Guid.NewGuid(), IPAddress.Parse("192.168.1.2"), DateTime.Now, false, new Uri("http://localhost/a")); this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); MockCallback(callback); // Act. var result = await Subject.PostAsync(request, cancellationToken); // Assert. var callbackId = Assert.Contains(CallbackId, ResponseHeaders); var accepted = Assert.IsType <AcceptedResult>(result); var response = Assert.IsType <ReceivingResponse>(accepted.Value); Assert.Equal(callback.Id.ToString(), callbackId); Assert.Null(accepted.Location); Assert.Equal(this.address.Address, response.Address); Assert.Equal(DateTime.UtcNow + TimeSpan.FromHours(1), response.Deadline, TimeSpan.FromSeconds(1)); this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); this.Callbacks.Verify( r => r.AddAsync(callback.RegisteredIp, callback.Url, CancellationToken.None), Times.Once()); this.watcher.Verify( w => w.StartWatchAsync( this.reservation, new PropertyAmount(1000), 6, TimeSpan.FromHours(1), new TokenReceivingCallback(callback, ReceivingController.TimeoutStatus), CancellationToken.None), Times.Once()); this.pool.Verify( p => p.ReleaseAddressAsync(this.reservation.Id, It.IsAny <CancellationToken>()), Times.Never()); })); }
public Task PostAsync_ErrorWhileStoringCallback_ShouldReleaseAddressReservation() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var requester = IPAddress.Parse("192.168.1.2"); var callback = new Uri("http://localhost/a"); var ex = new Exception(); var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(10000), }; RequestHeaders.Add(CallbackUrl, callback.ToString()); Connection.SetupGet(c => c.RemoteIpAddress).Returns(requester); this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); this.Callbacks .Setup(r => r.AddAsync(It.IsAny <IPAddress>(), It.IsAny <Uri>(), It.IsAny <CancellationToken>())) .ThrowsAsync(ex); // Act. var result = await Assert.ThrowsAnyAsync <Exception>( () => Subject.PostAsync(request, cancellationToken)); // Assert. Assert.Same(ex, result); this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); this.Callbacks.Verify(r => r.AddAsync(requester, callback, CancellationToken.None), Times.Once()); this.watcher.Verify( w => w.StartWatchAsync( It.IsAny <ReceivingAddressReservation>(), It.IsAny <PropertyAmount>(), It.IsAny <int>(), It.IsAny <TimeSpan>(), It.IsAny <TokenReceivingCallback>(), It.IsAny <CancellationToken>()), Times.Never()); this.pool.Verify(p => p.ReleaseAddressAsync(this.reservation.Id, CancellationToken.None), Times.Once()); })); }
public Task PostAsync_NoCallback_ShouldNotWatchWithCallback() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(100), }; this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); // Act. var result = await Subject.PostAsync(request, cancellationToken); // Assert. var accepted = Assert.IsType <AcceptedResult>(result); var response = Assert.IsType <ReceivingResponse>(accepted.Value); Assert.Null(accepted.Location); Assert.Equal(this.address.Address, response.Address); Assert.Equal(DateTimeKind.Utc, response.Deadline.Kind); Assert.Equal(DateTime.UtcNow + TimeSpan.FromHours(1), response.Deadline, TimeSpan.FromSeconds(1)); this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); this.Callbacks.Verify( r => r.AddAsync(It.IsAny <IPAddress>(), It.IsAny <Uri>(), It.IsAny <CancellationToken>()), Times.Never()); this.watcher.Verify( w => w.StartWatchAsync( this.reservation, new PropertyAmount(100), 6, TimeSpan.FromHours(1), null, CancellationToken.None), Times.Once()); this.pool.Verify( p => p.ReleaseAddressAsync(this.reservation.Id, It.IsAny <CancellationToken>()), Times.Never()); })); }
public Task PostAsync_ErrorWhileStartWatching_ShouldReleaseAddressReservation() { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var ex = new Exception(); var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(5), }; this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); this.watcher .Setup(w => w.StartWatchAsync( It.IsAny <ReceivingAddressReservation>(), It.IsAny <PropertyAmount>(), It.IsAny <int>(), It.IsAny <TimeSpan>(), It.IsAny <TokenReceivingCallback>(), It.IsAny <CancellationToken>())) .ThrowsAsync(ex); // Act. var result = await Assert.ThrowsAnyAsync <Exception>( () => Subject.PostAsync(request, cancellationToken)); // Assert. this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); this.watcher.Verify( w => w.StartWatchAsync( this.reservation, new PropertyAmount(5), 6, TimeSpan.FromHours(1), null, CancellationToken.None), Times.Once()); this.pool.Verify(p => p.ReleaseAddressAsync(this.reservation.Id, CancellationToken.None), Times.Once()); })); }
public SaveRespone InsertReceivingDetails(JObject input) { SaveRespone objresponse = new SaveRespone(); try { ReceivingRequest objrequest = new ReceivingRequest(); objrequest.CounterId = Convert.ToInt32(CommonMethods.URLKeyDecrypt(Convert.ToString(input["CounterId"]))); objrequest.UserLoginId = Convert.ToInt32(CommonMethods.URLKeyDecrypt(Convert.ToString(input["UserLoginId"]))); objrequest.DriverMobileNumber = Convert.ToString(input["DriverMobileNumber"]); objrequest.DriverName = Convert.ToString(input["DriverName"]); objrequest.BookingId = Convert.ToInt32(input["BookingId"]); objrequest.FromCounter = Convert.ToString(input["FromCounter"]); objrequest.GCBookingNumber = Convert.ToString(input["GCBookingNumber"]); objrequest.GCType = Convert.ToInt32(input["GCType"]); objrequest.ProductType = Convert.ToInt32(input["ProductType"]); objrequest.Remarks = Convert.ToString(input["Remarks"]); objrequest.NumberOfPieces = Convert.ToInt32(input["NumberOfPieces"]); objrequest.DeliveryToName = Convert.ToString(input["DeliveryToName"]); objrequest.DeliveryToNumber = Convert.ToString(input["DeliveryToNumber"]); objrequest.HamaliCharges = Convert.ToDecimal(input["HamaliCharges"]); objrequest.ReceivingType = Convert.ToInt32(input["ReceivingType"]); objrequest.TranshipmentCharges = Convert.ToInt32(input["TranshipmentCharges"]); objrequest.TotalWeight = Convert.ToInt32(input["TotalWeight"]); objrequest.VehicleNumber = Convert.ToString(input["VehicleNumber"]); objrequest.ToBeReceiveId = Convert.ToInt32(input["ToBeReceiveId"]); objrequest.BillAmount = Convert.ToDecimal(input["BillAmount"]); objresponse = objBookingDal.InsertReceivingDetails(objrequest); } catch (Exception ex) { objresponse.StatusId = 0; objresponse.StatusMessage = ex.Message; } return(objresponse); }
public async Task <IActionResult> PostAsync( [FromBody] ReceivingRequest req, CancellationToken cancellationToken) { var timeout = this.config.Default.TransactionTimeout; var reserve = await this.pool.TryLockAddressAsync(cancellationToken); if (reserve == null) { return(StatusCode((int)HttpStatusCode.ServiceUnavailable)); } try { var callback = await this.helper.RegisterCallbackAsync(this, CancellationToken.None); await this.watcher.StartWatchAsync( reserve, req.TargetAmount.Value, this.config.Default.RequiredConfirmation, timeout, callback != null?new TokenReceivingCallback(callback, TimeoutStatus) : null, CancellationToken.None); } catch { await this.pool.ReleaseAddressAsync(reserve.Id, CancellationToken.None); throw; } return(Accepted(new ReceivingResponse() { Address = reserve.Address.Address, Deadline = DateTime.UtcNow + timeout, })); }
public Task PostAsync_WithInvalidCallbackUrl_ShouldReleaseAddressReservation(string url) { return(AsynchronousTesting.WithCancellationTokenAsync(async cancellationToken => { // Arrange. var request = new ReceivingRequest() { TargetAmount = new PropertyAmount(1), }; RequestHeaders.Add(CallbackUrl, url); this.pool .Setup(p => p.TryLockAddressAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(this.reservation); // Act. await Assert.ThrowsAsync <InvalidCallbackUrlException>( () => Subject.PostAsync(request, cancellationToken)); // Assert. this.pool.Verify(p => p.TryLockAddressAsync(cancellationToken), Times.Once()); this.watcher.Verify( w => w.StartWatchAsync( It.IsAny <ReceivingAddressReservation>(), It.IsAny <PropertyAmount>(), It.IsAny <int>(), It.IsAny <TimeSpan>(), It.IsAny <TokenReceivingCallback>(), It.IsAny <CancellationToken>()), Times.Never()); this.pool.Verify(p => p.ReleaseAddressAsync(this.reservation.Id, CancellationToken.None), Times.Once()); })); }