public static async Task UpdateAsync_InvokesAddOrUpdatePrimaryContact(
[Frozen] Mock <IContactDetailsService> contactDetailsService,
[Frozen] Mock <IOrderingPartyService> service,
[Frozen] CallOffId callOffId,
Order order,
OrderingPartyModel model,
OrderingPartyController controller)
{
var originalContact = order.OrderingPartyContact;
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order);
service.Setup(o => o.SetOrderingParty(order, It.IsAny <OrderingParty>(), It.IsAny <Contact>())).Callback(() =>
{
order.OrderingParty.Name = model.Name;
order.OrderingParty.OdsCode = model.OdsCode;
});
contactDetailsService.Setup(o => o.AddOrUpdatePrimaryContact(
It.Is <Contact>(c => c == originalContact),
It.Is <PrimaryContactModel>(c => c == model.PrimaryContact)))
.Returns(order.OrderingPartyContact);
await controller.UpdateAsync(callOffId, model);
contactDetailsService.Verify(s => s.AddOrUpdatePrimaryContact(
It.Is <Contact>(c => c == originalContact),
It.Is <PrimaryContactModel>(c => c == model.PrimaryContact)));
order.OrderingPartyContact.Should().BeEquivalentTo(originalContact);
}
public async Task <ActionResult> UpdateAsync(string orderId, OrderingPartyModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var order = await _orderRepository.GetOrderByIdAsync(orderId);
if (order is null)
{
return(NotFound());
}
var primaryOrganisationId = User.GetPrimaryOrganisationId();
if (primaryOrganisationId != order.OrganisationId)
{
return(Forbid());
}
order.OrganisationName = model.Name;
order.OrganisationOdsCode = model.OdsCode;
order.OrganisationContact = order.OrganisationContact.FromModel(model.PrimaryContact);
order.OrganisationAddress = order.OrganisationAddress.FromModel(model.Address);
var name = User.Identity.Name;
order.SetLastUpdatedBy(User.GetUserId(), name);
await _orderRepository.UpdateOrderAsync(order);
return(NoContent());
}
public static void Constructor_InitializesAddressToExpectedValue(
[Frozen] OrderingParty party)
{
var model = new OrderingPartyModel(party, null);
model.Address.Should().BeEquivalentTo(party.Address, o => o.Excluding(a => a.Id));
}
public static void Constructor_NullContact_InitializesContactToExpectedValue(
OrderingParty party)
{
var model = new OrderingPartyModel(party, null);
model.PrimaryContact.Should().BeNull();
}
public static void Constructor_InitializesOdsCodeToExpectedValue(
[Frozen] OrderingParty party)
{
var model = new OrderingPartyModel(party, null);
model.OdsCode.Should().Be(party.OdsCode);
}
public async Task <ActionResult> UpdateAsync(CallOffId callOffId, OrderingPartyModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var order = await orderingPartyService.GetOrder(callOffId);
if (order is null)
{
return(NotFound());
}
var orderingParty = new OrderingParty
{
Name = model.Name,
OdsCode = model.OdsCode,
Address = contactDetailsService.AddOrUpdateAddress(order.OrderingParty.Address, model.Address),
};
Contact contact = contactDetailsService.AddOrUpdatePrimaryContact(
order.OrderingPartyContact,
model.PrimaryContact);
await orderingPartyService.SetOrderingParty(order, orderingParty, contact);
return(NoContent());
}
public static void Constructor_NullAddress_InitializesAddressToExpectedValue(
[Frozen] OrderingParty party)
{
party.Address = null;
var model = new OrderingPartyModel(party, null);
model.Address.Should().BeNull();
}
public static async Task UpdateAsync_OrderDoesNotExist_ReturnsNotFound(
[Frozen] Mock <IOrderingPartyService> service,
CallOffId callOffId,
OrderingPartyModel model,
OrderingPartyController controller)
{
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync((Order)null);
var response = await controller.UpdateAsync(callOffId, model);
response.Should().BeOfType <NotFoundResult>();
}
public static async Task UpdateAsync_InvokesSetOrderingParty(
[Frozen] Mock <IOrderingPartyService> service,
[Frozen] CallOffId callOffId,
Order order,
OrderingPartyModel model,
OrderingPartyController controller)
{
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order);
service.Setup(o => o.SetOrderingParty(order, It.IsAny <OrderingParty>(), It.IsAny <Contact>())).Verifiable();
await controller.UpdateAsync(callOffId, model);
service.Verify(o => o.SetOrderingParty(order, It.IsAny <OrderingParty>(), It.IsAny <Contact>()), () => Times.AtMost(1));
}
public static void Constructor_InitializesContactToExpectedValue(
OrderingParty party,
Contact contact)
{
var model = new OrderingPartyModel(party, contact);
model.PrimaryContact.Should().BeEquivalentTo(new
{
contact.FirstName,
contact.LastName,
EmailAddress = contact.Email,
TelephoneNumber = contact.Phone,
});
}
public static async Task GetAsync_OrderExists_ReturnsTheOrderingParty(
[Frozen] Mock <IOrderingPartyService> service,
[Frozen] CallOffId callOffId,
Order order,
OrderingPartyController controller)
{
order.OrderingParty.Should().NotBeNull();
order.OrderingPartyContact.Should().NotBeNull();
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order);
var expectedValue = new OrderingPartyModel(order.OrderingParty, order.OrderingPartyContact);
var response = await controller.GetAsync(callOffId);
response.Value.Should().BeEquivalentTo(expectedValue);
}
public static async Task UpdateAsync_SuccessfulUpdate_ReturnsNoContentResult(
[Frozen] Mock <IOrderingPartyService> service,
[Frozen] CallOffId callOffId,
Order order,
OrderingPartyModel model,
OrderingPartyController controller)
{
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order);
service.Setup(o => o.SetOrderingParty(order, It.IsAny <OrderingParty>(), It.IsAny <Contact>())).Callback(() =>
{
order.OrderingParty.Name = model.Name;
order.OrderingParty.OdsCode = model.OdsCode;
});
var result = await controller.UpdateAsync(callOffId, model);
result.Should().BeOfType <NoContentResult>();
}
public async Task <ActionResult <OrderingPartyModel> > GetAsync(CallOffId callOffId)
{
var order = await orderingPartyService.GetOrder(callOffId);
if (order is null)
{
return(NotFound());
}
if (order.OrderingParty is null)
{
return(NotFound());
}
OrderingPartyModel orderingPartyModel = new OrderingPartyModel(
order.OrderingParty,
order.OrderingPartyContact);
return(orderingPartyModel);
}
public static async Task UpdateAsync_UpdatesOrderingParty(
[Frozen] Mock <IOrderingPartyService> service,
[Frozen] CallOffId callOffId,
Order order,
OrderingPartyModel model,
OrderingPartyController controller)
{
order.OrderingParty.Should().NotBeEquivalentTo(model);
service.Setup(o => o.GetOrder(callOffId)).ReturnsAsync(order);
service.Setup(o => o.SetOrderingParty(order, It.IsAny <OrderingParty>(), It.IsAny <Contact>())).Callback(() =>
{
order.OrderingParty.Name = model.Name;
order.OrderingParty.OdsCode = model.OdsCode;
});
await controller.UpdateAsync(callOffId, model);
order.OrderingParty.Should().BeEquivalentTo(
model,
o => o.Including(p => p.Name).Including(p => p.OdsCode));
}
public static void Constructor_NullOrderingParty_ThrowsArgumentNullException(Contact contact)
{
Assert.Throws <ArgumentNullException>(() => _ = new OrderingPartyModel(null, contact));
}
