public void TestToUpdatedEcaAddress()
        {
            var model = new UpdatedAddressBindingModel
            {
                IsPrimary     = true,
                AddressTypeId = AddressType.Business.Id,
                CityId        = 1,
                CountryId     = 2,
                DivisionId    = 3,
                PostalCode    = "12345",
                Street1       = "street1",
                Street2       = "street2",
                Street3       = "street3",
                AddressId     = 10
            };
            var user     = new User(1);
            var instance = model.ToUpdatedEcaAddress(user);

            Assert.AreEqual(model.IsPrimary, instance.IsPrimary);
            Assert.AreEqual(model.AddressTypeId, instance.AddressTypeId);
            Assert.AreEqual(model.CityId, instance.CityId);
            Assert.AreEqual(model.CountryId, instance.CountryId);
            Assert.AreEqual(model.DivisionId, instance.DivisionId);
            Assert.IsNull(instance.LocationName);
            Assert.AreEqual(model.PostalCode, instance.PostalCode);
            Assert.AreEqual(model.Street1, instance.Street1);
            Assert.AreEqual(model.Street2, instance.Street2);
            Assert.AreEqual(model.Street3, instance.Street3);
            Assert.AreEqual(model.AddressId, instance.AddressId);
            Assert.IsTrue(Object.ReferenceEquals(user, instance.Update.User));
        }
        public async Task TestPutAddressAsync()
        {
            var model    = new UpdatedAddressBindingModel();
            var response = await controller.PutAddressAsync(1, model);

            addressHandler.Verify(x => x.HandleUpdateAddressAsync(It.IsAny <UpdatedAddressBindingModel>(), It.IsAny <ApiController>()), Times.Once());
        }
        public async Task TestHandleUpdateAddressAsync_InvalidModel()
        {
            controller.ModelState.AddModelError("key", "error");
            var model = new UpdatedAddressBindingModel
            {
                AddressTypeId = AddressType.Business.Id,
            };
            var response = await handler.HandleUpdateAddressAsync(model, controller);

            Assert.IsInstanceOfType(response, typeof(InvalidModelStateResult));
        }
        public async Task TestPutUpdateAddressAsync()
        {
            var model = new UpdatedAddressBindingModel
            {
                AddressTypeId = AddressType.Business.Id,
            };

            userProvider.Setup(x => x.GetBusinessUser(It.IsAny <IWebApiUser>())).Returns(new User(1));
            var response = await handler.HandleUpdateAddressAsync(model, controller);

            Assert.IsInstanceOfType(response, typeof(OkNegotiatedContentResult <AddressDTO>));
            userProvider.Verify(x => x.GetCurrentUser(), Times.Once());
            userProvider.Verify(x => x.GetBusinessUser(It.IsAny <IWebApiUser>()), Times.Once());
            locationService.Verify(x => x.UpdateAsync(It.IsAny <UpdatedEcaAddress>()), Times.Once());
            locationService.Verify(x => x.SaveChangesAsync(), Times.Once());
            locationService.Verify(x => x.GetAddressByIdAsync(It.IsAny <int>()), Times.Once());
        }
 public Task <IHttpActionResult> PutAddressAsync(int organizationId, [FromBody] UpdatedAddressBindingModel model)
 {
     return(addressHandler.HandleUpdateAddressAsync(model, this));
 }