public async Task Put_Returns204_IfDeliveryIdExists()
{
// Arrange
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.CreateAsync(It.IsAny <InternalDelivery>())).Throws(new DuplicateResourceException("dupe", null));
deliveryRepository.Setup(r => r.UpdateAsync(It.IsAny <string>(), It.IsAny <InternalDelivery>())).Returns(Task.CompletedTask);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>()))
.Returns(new Mock <ILogger <DeliveriesController> >().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryTrackingEventRepository>().Object,
loggerFactory.Object);
// Act
var result = await target.Put(new Delivery("existingdeliveryid", new UserAccount("user", "account"), new Location(0, 0, 0), new Location(2, 2, 2), "deadline", true, ConfirmationType.FingerPrint, "drone"), "existingdeliveryid");
var statusCodeResult = (StatusCodeResult)result;
// Assert
Assert.IsNotNull(statusCodeResult);
Assert.AreEqual(204, statusCodeResult.StatusCode);
}
public async Task Put_AddscreatedDeliveryEvent()
{
// Arrange
DeliveryTrackingEvent createdDelivery = null;
var deliveryStatusEventRepository = new Mock <IDeliveryTrackingEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryTrackingEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryTrackingEvent>(e => createdDelivery = e);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(new Mock <IDeliveryRepository>().Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
// Act
var result = await target.Put(new Delivery("deliveryid", new UserAccount("user", "account"), new Location(0, 0, 0), new Location(2, 2, 2), "deadline", true, ConfirmationType.FingerPrint, "drone"), "deliveryid");
var createdAtRouteResult = (CreatedAtRouteResult)result;
// Assert
Assert.AreEqual(201, createdAtRouteResult.StatusCode);
Assert.IsNotNull(createdAtRouteResult.Value);
Assert.IsNotNull(createdDelivery);
Assert.AreEqual(DeliveryStage.Created, createdDelivery.Stage);
deliveryStatusEventRepository.VerifyAll();
}
public async Task GetOwner_ReturnsOwner()
{
// Arrange
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync(It.IsAny <string>()))
.ReturnsAsync(delivery);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryTrackingEventRepository>().Object,
loggerFactory.Object);
// Act
var result = await target.GetOwner("deliveryid") as OkObjectResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(userAccount, result.Value);
}
public async Task Cannot_add_Delivery_when_it_already_exists()
{
const string DELIVERY_ID = "DL001";
const string SITE_CODE = "SITE001";
const int ORDER_REFERENCE = 1;
const string STATUS = "ON PROCESS";
using (var context = new ProcurementDbContext(ContextOptions))
{
DeliveriesController deliveriesController = new DeliveriesController(context);
DeliveryDTO deliveryDto = new DeliveryDTO {
DeliveryId = DELIVERY_ID, SiteCode = SITE_CODE, PurchaseOrder = ORDER_REFERENCE, DeliveryStatus = STATUS
};
try
{
await deliveriesController.PostDelivery(deliveryDto);
}
catch (Exception exception)
{
Assert.NotNull(exception);
return;
}
Assert.True(false);
}
}
public async Task GetSummry_ReturnsSummary()
{
const int TestDeliveryCount = 5000;
// Arrange
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetDeliveryCountAsync("owner", 2019, 01))
.ReturnsAsync(TestDeliveryCount)
.Verifiable();
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryTrackingEventRepository>().Object,
loggerFactory.Object);
// Act
var result = await target.GetSummary("owner", 2019, 01) as OkObjectResult;
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Value, typeof(DeliveriesSummary));
Assert.AreEqual(TestDeliveryCount, ((DeliveriesSummary)result.Value).Count);
deliveryRepository.VerifyAll();
}
public DeliveriesControllerTests()
{
_mockDeliveryService = new Mock <IDeliveryService>();
_mockExecutionContext = new Mock <IExecutionContext>();
var mockLogger = new Mock <ILogger <DeliveriesController> >();
_deliveriesController = new DeliveriesController(_mockDeliveryService.Object, _mockExecutionContext.Object,
mockLogger.Object);
}
public async Task Delete_SendsMessageWithCancelledEvent()
{
// Arrange
InternalDelivery cancelledDelivery = null;
DeliveryStatusEvent cancelEvent = null;
DeliveryStatusEvent[] allEvents = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var deliveryHistoryService = new Mock <IDeliveryHistoryService>();
deliveryHistoryService.Setup(r => r.CancelAsync(It.IsAny <InternalDelivery>(), It.IsAny <DeliveryStatusEvent[]>()))
.Returns(Task.CompletedTask)
.Callback <InternalDelivery, DeliveryStatusEvent[]>((d, es) =>
{
cancelledDelivery = d;
allEvents = es;
});
var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryStatusEvent>(e => cancelEvent = e);
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryStatusEvent>(new List <DeliveryStatusEvent>()
{
cancelEvent
}));
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
deliveryHistoryService.Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
// Act
await target.Delete("deliveryid");
// Assert
Assert.IsNotNull(cancelEvent);
Assert.AreEqual("deliveryid", cancelEvent.DeliveryId);
Assert.AreEqual(DeliveryEventType.Cancelled, cancelEvent.Stage);
deliveryRepository.VerifyAll();
deliveryHistoryService.Verify(s => s.CancelAsync(delivery, allEvents), Times.Once);
}
public async Task Can_get_all_Delivery_details_in_database()
{
using (var context = new ProcurementDbContext(ContextOptions))
{
DeliveriesController deliveriesController = new DeliveriesController(context);
var result = await deliveriesController.GetDeliveries();
var viewResult = Assert.IsType <ActionResult <IEnumerable <Delivery> > >(result);
var delivery = Assert.IsType <List <Delivery> >(viewResult.Value);
Assert.Single(delivery);
}
}
public async Task Confirm_DeletesDeliveryLogically()
{
// Arrange
InternalDelivery confirmedDelivery = null;
DeliveryStatusEvent completeEvent = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
deliveryRepository.Setup(r => r.DeleteAsync("deliveryid", It.IsAny <InternalDelivery>()))
.Returns(Task.CompletedTask)
.Callback <string, InternalDelivery>((i, d) => confirmedDelivery = d);
var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryStatusEvent>(e => completeEvent = e);
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryStatusEvent>(new List <DeliveryStatusEvent>()
{
completeEvent
}));
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryHistoryService>().Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
var location = new Location(1, 2, 3);
var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
location,
ConfirmationType.Picture,
"confirmationblob");
// Act
var result = await target.Confirm("deliveryid", confirmation) as OkResult;
// Assert
Assert.IsNotNull(result);
deliveryRepository.Verify(r => r.DeleteAsync("deliveryid", confirmedDelivery));
Assert.AreEqual(location, confirmedDelivery.Dropoff);
}
public async Task GetStatus_Returns404_IfDeliveryIdNotValid()
{
// Arrange
var logger = new Mock <ILogger <DeliveriesController> >();
var target = new DeliveriesController(new Mock <IDeliveryRepository>().Object,
logger.Object);
// Act
var result = await target.GetStatus("invaliddeliveryid") as NotFoundResult;
// Assert
Assert.NotNull(result);
Assert.Equal(404, result.StatusCode);
}
public async Task Should_not_return_Delivery_when_unavailable()
{
const string DELIVERY_ID = "DL0001";
using (var context = new ProcurementDbContext(ContextOptions))
{
DeliveriesController deliveriesController = new DeliveriesController(context);
var result = await deliveriesController.GetDelivery(DELIVERY_ID);
var viewResult = Assert.IsType <ActionResult <Delivery> >(result);
Assert.IsNotType <Delivery>(viewResult.Value);
var response = Assert.IsType <NotFoundResult>(viewResult.Result);
Assert.Equal(404, response.StatusCode);
}
}
public async Task Can_get_Delivery_By_Id()
{
const string DELIVERY_ID = "DL001";
using (var context = new ProcurementDbContext(ContextOptions))
{
DeliveriesController deliveriesController = new DeliveriesController(context);
var result = await deliveriesController.GetDelivery(DELIVERY_ID);
var viewResult = Assert.IsType <ActionResult <Delivery> >(result);
var delivery = Assert.IsType <Delivery>(viewResult.Value);
Assert.Equal(DELIVERY_ID, delivery.DeliveryId);
}
}
public async Task Confirm_AddsDeliveryCompletedEvent()
{
// Arrange
DeliveryTrackingEvent completedDelivery = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var deliveryStatusEventRepository = new Mock <IDeliveryTrackingEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryTrackingEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryTrackingEvent>(e => completedDelivery = e);
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryTrackingEvent>(new List <DeliveryTrackingEvent>()
{
completedDelivery
}));
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
new Location(1, 2, 3),
ConfirmationType.Picture,
"confirmationblob");
// Act
var result = await target.Confirm("deliveryid", confirmation) as OkResult;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(completedDelivery);
Assert.AreEqual(DeliveryStage.Completed, completedDelivery.Stage);
}
public async Task Confirm_Returns404_IfDeliveryIdNotValid()
{
// Arrange
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(new Mock <IDeliveryRepository>().Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryTrackingEventRepository>().Object,
loggerFactory.Object);
// Act
var result = await target.Confirm("invaliddeliveryid", null) as NotFoundResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(404, result.StatusCode);
}
public async Task Patch_UpdatesCache()
{
// Arrange
InternalDelivery updatedDelivery = null;
var rescheduledDelivery = new RescheduledDelivery(new Location(2, 2, 2),
new Location(3, 3, 3),
"newdeadline");
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
deliveryRepository.Setup(r => r.UpdateAsync("deliveryid", It.IsAny <InternalDelivery>()))
.Returns(Task.CompletedTask)
.Callback((string i, InternalDelivery d) => updatedDelivery = d);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryHistoryService>().Object,
new Mock <IDeliveryStatusEventRepository>().Object,
loggerFactory.Object);
// Act
await target.Patch("deliveryid", rescheduledDelivery);
// Assert
//unchanged values
Assert.AreEqual("deliveryid", updatedDelivery.Id);
Assert.AreEqual("userid", updatedDelivery.Owner.UserId);
//updated values
Assert.AreEqual(2, updatedDelivery.Pickup.Altitude);
Assert.AreEqual(3, updatedDelivery.Dropoff.Altitude);
Assert.AreEqual("newdeadline", updatedDelivery.Deadline);
deliveryRepository.VerifyAll();
}
public async Task Put_AddsToRepository()
{
// Arrange
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.CreateAsync(It.IsAny <Delivery>())).ReturnsAsync(true);
var logger = new Mock <ILogger <DeliveriesController> >();
var target = new DeliveriesController(deliveryRepository.Object,
logger.Object);
// Act
var result = await target.Put(new Delivery("deliveryid", new UserAccount("user", "account"), new Location(0, 0, 0), new Location(2, 2, 2), "deadline", true, ConfirmationType.FingerPrint, "drone"), "deliveryid");
var createdAtRouteResult = (CreatedAtRouteResult)result;
// Assert
Assert.Equal(201, createdAtRouteResult.StatusCode);
Assert.NotNull(createdAtRouteResult.Value);
deliveryRepository.VerifyAll();
}
public async Task Patch_AddsRescheduledDeliveryEvent()
{
// Arrange
DeliveryStatusEvent rescheduledEvent = null;
var rescheduledDelivery = new RescheduledDelivery(new Location(2, 2, 2),
new Location(3, 3, 3),
"newdeadline");
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryStatusEvent>(e => rescheduledEvent = e);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryHistoryService>().Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
// Act
var result = await target.Patch("deliveryid", rescheduledDelivery) as OkResult;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(rescheduledEvent);
Assert.AreEqual(DeliveryEventType.Rescheduled, rescheduledEvent.Stage);
deliveryStatusEventRepository.VerifyAll();
}
public async Task Put_Returns204_IfDeliveryIdExists()
{
// Arrange
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.CreateAsync(It.IsAny <Delivery>())).ReturnsAsync(false);
deliveryRepository.Setup(r => r.UpdateAsync(It.IsAny <string>(), It.IsAny <Delivery>())).Returns(Task.CompletedTask);
var logger = new Mock <ILogger <DeliveriesController> >();
var target = new DeliveriesController(deliveryRepository.Object,
logger.Object);
// Act
var result = await target.Put(new Delivery("existingdeliveryid", new UserAccount("user", "account"), new Location(0, 0, 0), new Location(2, 2, 2), "deadline", true, ConfirmationType.FingerPrint, "drone"), "existingdeliveryid");
var statusCodeResult = (StatusCodeResult)result;
// Assert
Assert.NotNull(statusCodeResult);
Assert.Equal(204, statusCodeResult.StatusCode);
}
public async Task Delete_SendsMessageWithCancelledTrackingEvent()
{
// Arrange
DeliveryTrackingEvent cancelledDelivery = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var deliveryStatusEventRepository = new Mock <IDeliveryTrackingEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryTrackingEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryTrackingEvent>(e => cancelledDelivery = e);
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryTrackingEvent>(new List <DeliveryTrackingEvent>()
{
cancelledDelivery
}));
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
new Mock <INotifyMeRequestRepository>().Object,
new Mock <INotificationService>().Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
// Act
await target.Delete("deliveryid");
// Assert
Assert.IsNotNull(cancelledDelivery);
Assert.AreEqual("deliveryid", cancelledDelivery.DeliveryId);
Assert.AreEqual(DeliveryStage.Cancelled, cancelledDelivery.Stage);
deliveryRepository.VerifyAll();
}
public async Task Can_add_new_Delivery_when_it_not_existing()
{
const string DELIVERY_ID = "DL002";
const string SITE_CODE = "SITE001";
const int ORDER_REFERENCE = 1;
const string STATUS = "ON PROCESS";
using (var context = new ProcurementDbContext(ContextOptions))
{
DeliveriesController deliveriesController = new DeliveriesController(context);
DeliveryDTO deliveryDto = new DeliveryDTO {
DeliveryId = DELIVERY_ID, SiteCode = SITE_CODE, PurchaseOrder = ORDER_REFERENCE, DeliveryStatus = STATUS
};
var result = await deliveriesController.PostDelivery(deliveryDto);
var viewResult = Assert.IsType <ActionResult <Delivery> >(result);
var actionResult = Assert.IsType <CreatedAtActionResult>(viewResult.Result);
var delivery = Assert.IsType <Delivery>(actionResult.Value);
Assert.Equal(DELIVERY_ID, delivery.DeliveryId);
}
}
public async Task NotifyMe_AddsNotifyMeRequest()
{
// Arrange
InternalNotifyMeRequest savedNotifyMeRequest = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var notifyMeRequestRepository = new Mock <INotifyMeRequestRepository>();
notifyMeRequestRepository.Setup(r => r.AddAsync(It.IsAny <InternalNotifyMeRequest>()))
.Returns(Task.CompletedTask)
.Callback <InternalNotifyMeRequest>(r => savedNotifyMeRequest = r);
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
notifyMeRequestRepository.Object,
new Mock <INotificationService>().Object,
new Mock <IDeliveryHistoryService>().Object,
new Mock <IDeliveryStatusEventRepository>().Object,
loggerFactory.Object);
var notifyMeRequest = new NotifyMeRequest("*****@*****.**", "1234567");
// Act
var result = await target.NotifyMe("deliveryid", notifyMeRequest) as NoContentResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("deliveryid", savedNotifyMeRequest.DeliveryId);
Assert.AreEqual("*****@*****.**", savedNotifyMeRequest.EmailAddress);
Assert.AreEqual("1234567", savedNotifyMeRequest.SMS);
}
public async Task Confirm_SendsMessageCompleteToDeliveryHistory()
{
// Arrange
InternalDelivery confirmedDelivery = null;
InternalConfirmation sentConfirmation = null;
DeliveryStatusEvent completeEvent = null;
DeliveryStatusEvent[] allEvents = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var notifyMeRequestRepository = new Mock <INotifyMeRequestRepository>();
notifyMeRequestRepository.Setup(r => r.GetAllByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new List <InternalNotifyMeRequest>());
var deliveryStatusEventRepository = new Mock <IDeliveryStatusEventRepository>();
deliveryStatusEventRepository.Setup(r => r.AddAsync(It.IsAny <DeliveryStatusEvent>()))
.Returns(Task.CompletedTask)
.Callback <DeliveryStatusEvent>(e => completeEvent = e);
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryStatusEvent>(new List <DeliveryStatusEvent>()
{
completeEvent
}));
var deliveryHistoryService = new Mock <IDeliveryHistoryService>();
deliveryHistoryService.Setup(r => r.CompleteAsync(It.IsAny <InternalDelivery>(), It.IsAny <InternalConfirmation>(), It.IsAny <DeliveryStatusEvent[]>()))
.Returns(Task.CompletedTask)
.Callback <InternalDelivery, InternalConfirmation, DeliveryStatusEvent[]>((d, c, es) =>
{
confirmedDelivery = d;
sentConfirmation = c;
allEvents = es;
});
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
notifyMeRequestRepository.Object,
new Mock <INotificationService>().Object,
deliveryHistoryService.Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
new Location(1, 2, 3),
ConfirmationType.Picture,
"confirmationblob");
// Act
var result = await target.Confirm("deliveryid", confirmation) as OkResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("datetimevalue", sentConfirmation.DateTime.DateTimeValue);
Assert.AreEqual(1, sentConfirmation.GeoCoordinates.Altitude);
Assert.AreEqual(2, sentConfirmation.GeoCoordinates.Latitude);
Assert.AreEqual(3, sentConfirmation.GeoCoordinates.Longitude);
Assert.AreEqual(ConfirmationType.Picture, sentConfirmation.ConfirmationType);
Assert.AreEqual("confirmationblob", sentConfirmation.ConfirmationBlob);
deliveryHistoryService.Verify(s => s.CompleteAsync(confirmedDelivery, It.IsAny <InternalConfirmation>(), allEvents), Times.Once);
}
public DeliveriesControllerTests()
{
_service = new Mock <IDeliveryService>();
_controller = new DeliveriesController(_service.Object);
}
public async Task Confirm_SendsNotifications()
{
// Arrange
DeliveryTrackingEvent completedDelivery = null;
var deliveryRepository = new Mock <IDeliveryRepository>();
deliveryRepository.Setup(r => r.GetAsync("deliveryid")).ReturnsAsync(delivery);
var notifyMeRequests = new List <InternalNotifyMeRequest>();
notifyMeRequests.Add(new InternalNotifyMeRequest
{
DeliveryId = "deliveryid", EmailAddress = "*****@*****.**", SMS = "1111111"
});
notifyMeRequests.Add(new InternalNotifyMeRequest
{
DeliveryId = "deliveryid", EmailAddress = "*****@*****.**", SMS = "2222222"
});
var notifyMeRequestRepository = new Mock <INotifyMeRequestRepository>();
notifyMeRequestRepository.Setup(r => r.GetAllByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(notifyMeRequests);
int notificationServiceCalled = 0;
var notificationService = new Mock <INotificationService>();
notificationService.Setup(s => s.SendNotificationsAsync(It.IsAny <InternalNotifyMeRequest>()))
.Returns(Task.CompletedTask)
.Callback(() => notificationServiceCalled++);
var deliveryStatusEventRepository = new Mock <IDeliveryTrackingEventRepository>();
deliveryStatusEventRepository.Setup(r => r.GetByDeliveryIdAsync("deliveryid"))
.ReturnsAsync(new ReadOnlyCollection <DeliveryTrackingEvent>(new List <DeliveryTrackingEvent>()
{
completedDelivery
}));
var loggerFactory = new Mock <ILoggerFactory>();
loggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(new Mock <ILogger>().Object);
var target = new DeliveriesController(deliveryRepository.Object,
notifyMeRequestRepository.Object,
notificationService.Object,
deliveryStatusEventRepository.Object,
loggerFactory.Object);
var confirmation = new Confirmation(new DateTimeStamp("datetimevalue"),
new Location(1, 2, 3),
ConfirmationType.Picture,
"confirmationblob");
// Acts
var result = await target.Confirm("deliveryid", confirmation) as OkResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(2, notificationServiceCalled);
}
