public async Task GetPreferredAddress_ShouldReturnAddress_GivenAddress(
                [Frozen] Mock <IMediator> mockMediator,
                Core.Handlers.GetPreferredAddress.AddressDto address,
                [Greedy] CustomerController sut,
                GetPreferredAddressQuery query
                )
            {
                //Arrange
                mockMediator.Setup(x => x.Send(
                                       It.IsAny <GetPreferredAddressQuery>(),
                                       It.IsAny <CancellationToken>()
                                       ))
                .ReturnsAsync(address);

                //Act
                var actionResult = await sut.GetPreferredAddress(query);

                //Assert
                var okObjectResult = actionResult as OkObjectResult;

                okObjectResult.Should().NotBeNull();

                var result = okObjectResult.Value as Core.Handlers.GetPreferredAddress.AddressDto;

                result.Should().Be(address);
            }
            public async Task GetPreferredShippingAddress_CustomerDoesNotExist_ThrowCustomerNotFoundException(
                [Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
                GetPreferredAddressQueryHandler sut,
                GetPreferredAddressQuery query
                )
            {
                //Arrange
                query.AddressType = "Shipping";

                customerRepoMock.Setup(_ => _.GetBySpecAsync(
                                           It.IsAny <GetCustomerAddressesSpecification>(),
                                           It.IsAny <CancellationToken>()
                                           ))
                .ReturnsAsync((Entities.StoreCustomer)null);

                //Act
                Func <Task> func = async() => await sut.Handle(query, CancellationToken.None);

                //Assert
                await func.Should().ThrowAsync <CustomerNotFoundException>();

                customerRepoMock.Verify(x => x.GetBySpecAsync(
                                            It.IsAny <GetCustomerAddressesSpecification>(),
                                            It.IsAny <CancellationToken>()
                                            ));
            }
            public async Task GetPreferredShippingAddress_NoAddressFound_ReturnAddress(
                [Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
                GetPreferredAddressQueryHandler sut,
                GetPreferredAddressQuery query,
                Entities.StoreCustomer customer
                )
            {
                //Arrange
                query.AddressType = "Shipping";

                customerRepoMock.Setup(_ => _.GetBySpecAsync(
                                           It.IsAny <GetCustomerAddressesSpecification>(),
                                           It.IsAny <CancellationToken>()
                                           ))
                .ReturnsAsync(customer);

                //Act
                var result = await sut.Handle(query, CancellationToken.None);

                //Assert
                result.Should().BeNull();

                customerRepoMock.Verify(x => x.GetBySpecAsync(
                                            It.IsAny <GetCustomerAddressesSpecification>(),
                                            It.IsAny <CancellationToken>()
                                            ));
            }
            public async Task GetPreferredAddress_ShouldReturnNotFound_WhenGivenNoCustomer(
                [Frozen] Mock <IMediator> mockMediator,
                [Greedy] CustomerController sut,
                GetPreferredAddressQuery query
                )
            {
                //Arrange
                mockMediator.Setup(x => x.Send(
                                       It.IsAny <GetPreferredAddressQuery>(),
                                       It.IsAny <CancellationToken>()
                                       ))
                .ReturnsAsync((Core.Handlers.GetPreferredAddress.AddressDto)null);

                //Act
                var actionResult = await sut.GetPreferredAddress(query);

                //Assert
                var notFoundResult = actionResult as NotFoundResult;

                notFoundResult.Should().NotBeNull();
            }
            public async Task GetPreferredBillingAddress_HomeAddressExists_ReturnAddress(
                [Frozen] Mock <IRepository <Entities.Customer> > customerRepoMock,
                GetPreferredAddressQueryHandler sut,
                GetPreferredAddressQuery query,
                Entities.IndividualCustomer customer,
                Entities.Address address
                )
            {
                //Arrange
                query.AddressType = "Billing";
                customer.AddAddress(
                    new Entities.CustomerAddress(
                        "Home",
                        address
                        )
                    );

                customerRepoMock.Setup(_ => _.GetBySpecAsync(
                                           It.IsAny <GetCustomerAddressesSpecification>(),
                                           It.IsAny <CancellationToken>()
                                           ))
                .ReturnsAsync(customer);

                //Act
                var result = await sut.Handle(query, CancellationToken.None);

                //Assert
                result.Should().BeEquivalentTo(
                    address,
                    opt => opt.Excluding(_ => _.SelectedMemberPath.EndsWith("Id", StringComparison.InvariantCultureIgnoreCase))
                    );

                customerRepoMock.Verify(x => x.GetBySpecAsync(
                                            It.IsAny <GetCustomerAddressesSpecification>(),
                                            It.IsAny <CancellationToken>()
                                            ));
            }