public void CheckDeleteAddress_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
// arrange
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
// act
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// Assign values to address object -> this object store in memory database
var address = new Address()
{
Address1 = "Test1", Address2 = "Test2", City = "Lahore", State = "Punjab", ZipCode = "54000"
};
DeliveryContext.Addresses.Add(address);
DeliveryContext.SaveChanges();
// Initialize AddressesController and put our inMemory context to its constructor
var controller = new AddressesController(DeliveryContext);
//ASSERT
//check Addresses is exist or not
var returnData = controller.DeleteAddress(1);
// We are confirming here the deleted object is of type address.
Assert.IsType <Address>(returnData.Result.Value);
}
protected void BindRentalsList()
{
//standard lookup
try
{
RentalsController sysmgr = new RentalsController();
List <Rentals> info = null;
AddressesController addControl = new AddressesController();
if (!string.IsNullOrEmpty(LandlordList.SelectedValue))
{
info = sysmgr.Rentals_FindByLandlord(int.Parse(LandlordList.SelectedValue));
foreach (Rentals item in info) // Loop through List with foreach
{
item.AddressName = (addControl.Addresses_FindByID(item.AddressID)).FullAddress;
}
info.Sort((x, y) => x.AddressName.CompareTo(y.AddressName));
AddressSearchList.DataSource = info;
AddressSearchList.DataTextField = nameof(Rentals.AddressName);
AddressSearchList.DataValueField = nameof(Rentals.RentalID);
AddressSearchList.DataBind();
AddressSearchList.Items.Insert(0, "Select an Address...");
}
}
catch (Exception ex)
{
errormsgs.Add(GetInnerException(ex).ToString());
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
}
public async void GetAddress()
{
using (var context = new AdventureWorks2014Context(_dbContextOptions))
{
var addressApi = new AddressesController(context);
for (int i = 0; i < 10; ++i)
{
Address address = new Address();
address.AddressLine1 = "Address line 1";
address.AddressLine2 = "Address line 2";
address.City = "Zagreb";
address.PostalCode = $"1234{ i }";
addressApi.PostAddress(address).Wait();
}
}
using (var context = new AdventureWorks2014Context(_dbContextOptions))
{
var addressApi = new AddressesController(context);
var result = await addressApi.GetAddress(5);
var okResult = result as OkObjectResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
Address address = okResult.Value as Address;
Assert.NotNull(address);
Assert.Equal("12344", address.PostalCode);
}
}
public void GetAddress_ById_Async_Return_Address_OkObjectResult()
{
//Arrange
AddressDomainModel addressDomainModel = new AddressDomainModel
{
Id = 123,
CityName = "Zrenjanin",
StreetName = "Nikole Pasica"
};
int expectedStatusCode = 200;
Task <AddressDomainModel> responseTask = Task.FromResult(addressDomainModel);
_addressService = new Mock <IAddressService>();
_addressService.Setup(x => x.GetByIdAsync(It.IsAny <int>())).Returns(responseTask);
AddressesController addressController = new AddressesController(_addressService.Object);
//Act
var result = addressController.GetAddressById(addressDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var objectResult = ((OkObjectResult)result).Value;
AddressDomainModel addressDomainResult = (AddressDomainModel)objectResult;
//Assert
Assert.IsNotNull(objectResult);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
Assert.AreEqual(addressDomainModel.Id, addressDomainResult.Id);
}
public void GetAsync_Return_All_Addresses()
{
//Arrange
List <AddressDomainModel> addressesDomainModelsList = new List <AddressDomainModel>();
AddressDomainModel addressDomainModel = new AddressDomainModel
{
Id = 1,
CityName = "ImeGrada",
StreetName = "ImeUlice"
};
addressesDomainModelsList.Add(addressDomainModel);
IEnumerable <AddressDomainModel> addressDomainModels = addressesDomainModelsList;
Task <IEnumerable <AddressDomainModel> > responseTask = Task.FromResult(addressDomainModels);
int expectedResultCount = 1;
int expectedStatusCode = 200;
_addressService = new Mock <IAddressService>();
_addressService.Setup(x => x.GetAllAsync()).Returns(responseTask);
AddressesController addressesController = new AddressesController(_addressService.Object);
//Act
var result = addressesController.GetAllAddresses().ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((OkObjectResult)result).Value;
var addressDomainModelResultList = (List <AddressDomainModel>)resultList;
//Assert
Assert.IsNotNull(addressDomainModelResultList);
Assert.AreEqual(expectedResultCount, addressDomainModelResultList.Count);
Assert.AreEqual(addressDomainModel.Id, addressDomainModelResultList[0].Id);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Update()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Put(It.IsAny <AddressDtoUpdate>())).ReturnsAsync(
new AddressDtoUpdateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
UpdatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
_controller.ModelState.AddModelError("Street", "Logradouro é obrigatório.");
var addressDtoUpdate = new AddressDtoUpdate
{
Id = Guid.NewGuid(),
Street = "Rua Morom"
};
var result = await _controller.Put(addressDtoUpdate);
Assert.True(result is BadRequestObjectResult);
}
public async Task Search_Post()
{
string searchTitle = "searchTitle";
string searchPostalCode = "searchPostalCode";
string searchPrefectures = "searchPrefectures";
string searchCtiy = "searchCtiy";
string searchBlock = "searchBlock";
string searchBuilding = "searchBuilding";
string searchRemarks = "searchRemarks";
// Arrange
var testUserId = "testUserId";
var mockRepo = new Mock <IAddressesRepository>();
mockRepo.Setup(repo => repo.SearchAsync(testUserId, searchTitle, searchPostalCode, searchPrefectures, searchCtiy, searchBlock, searchBuilding, searchRemarks))
.ReturnsAsync((List <Address>)null);
var controller = new AddressesController(mockRepo.Object);
// Act
var result = await controller.Search(searchTitle, searchPostalCode, searchPrefectures, searchCtiy, searchBlock, searchBuilding, searchRemarks);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
//var model = Assert.IsAssignableFrom<IEnumerable<Address>>(viewResult.ViewData.Model);
Assert.Null(viewResult.ViewData.Model);
Assert.Equal("Index", viewResult.ViewName);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Update()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Put(It.IsAny <AddressDtoUpdate>())).ReturnsAsync(
new AddressDtoUpdateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
UpdatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
var addressDtoUpdate = new AddressDtoUpdate
{
Id = Guid.NewGuid(),
Street = "Rua Morom"
};
var result = await _controller.Put(addressDtoUpdate);
Assert.True(result is OkObjectResult);
var resultValue = ((OkObjectResult)result).Value as AddressDtoUpdateResult;
Assert.NotNull(resultValue);
Assert.Equal(addressDtoUpdate.Street, resultValue.Street);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Post(It.IsAny <AddressDtoCreate>())).ReturnsAsync(
new AddressDtoCreateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
CreatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
_controller.ModelState.AddModelError("Street", "Logradouro é obrigatório.");
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var addressDtoCreate = new AddressDtoCreate
{
Street = "Rua Morom"
};
var result = await _controller.Post(addressDtoCreate);
Assert.True(result is BadRequestObjectResult);
}
public async void TestEdit_InvalidAddress_ShouldFail(string value)
{
// Arrange
AddressesController controller = new AddressesController(_context);
int addressId = int.Parse(value);
// Act
Address replayAddress = await _context.Address
.FirstOrDefaultAsync(a => a.AddressId == addressId);
replayAddress.ProvinceCode = "green";
try
{
var result = await controller.Edit(replayAddress.AddressId, replayAddress);
// Assert
Assert.IsType <ViewResult>(result);
ViewResult viewResult = (ViewResult)result;
Assert.NotNull(viewResult.ViewData.ModelState);
Assert.NotEmpty(viewResult.ViewData.ModelState.Keys);
foreach (string item in viewResult.ViewData.ModelState.Keys)
{
Assert.Equal("", item);
}
}
catch (Exception ex)
{
Assert.Equal("Microsoft.EntityFrameworkCore.DbUpdateException", ex.GetType().ToString());
}
}
public async void UpdateAddressAsync_Returns_NotFound_404_When_Update_With_null_Address()
{
//expected return error message
string expectedResponseMessage = "No Address was updated";
///set mockRepo return for Update action
_mockRepository.Setup(repo => repo.UpdateTAsync(null)).ReturnsAsync(0);
//instantiate the controller, and call the method
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Create Custom ControllerContext and add it to Controller for logging in the Controller in case of error
controller.ControllerContext = new ControllerContextModel();
//Call the SUT method
var actionResult = await controller.UpdateAddressAsync(1, null);
//Get the int result from the posted ActionResult
var notFoundObjectResult = actionResult.Result as NotFoundObjectResult;
var statusCode = notFoundObjectResult.StatusCode;
string actualResponseMessage = (string)notFoundObjectResult.Value;
//Assert the result
Assert.NotNull(actionResult);
//Validate the return status code
Assert.Equal(404, statusCode);
//Validate the result
Assert.Equal(expectedResponseMessage, actualResponseMessage);
}
public async void UpdateAddressAsync_Updates_One_Address_And_Returns_200_And_Address_Updated()
{
//declare a Contact
Address address = _addresses.FirstOrDefault();
AddressDTO expectedDto = _mapper.Map <AddressDTO>(address);
//set repo return for getting the object to update
_mockRepository.Setup(repo => repo.GetOneByAsync(ad => ad.Id == address.Id)).ReturnsAsync(address);
//set mockRepo return for Update action
_mockRepository.Setup(repo => repo.UpdateTAsync(address)).ReturnsAsync(1);
//instantiate the controller, passing the repo object
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
//returns ActionResult<BillableActivity> type
var actionResult = await controller.UpdateAddressAsync(address.Id, address);
//Get the int result from the posted ActionResult
var okObjectResult = actionResult.Result as OkObjectResult;
var statusCode = okObjectResult.StatusCode;
AddressDTO dto = okObjectResult.Value as AddressDTO;
//Assert the result
Assert.NotNull(actionResult);
//Validate StatusCode
Assert.Equal(200, statusCode);
//Validate the actual BillableActivity
dto.Should().BeEquivalentTo(expectedDto, options => options.ComparingByMembers <AddressDTO>());
}
public void TestInit()
{
userProvider = new Mock <IUserProvider>();
locationService = new Mock <ILocationService>();
addressTypeService = new Mock <IAddressTypeService>();
controller = new AddressesController(locationService.Object, userProvider.Object, addressTypeService.Object);
}
public async void AddAddressAsync_Creates_One_Address_And_Returns_201_And_Address_Created()
{
//declare address
Address address = _addresses.First();
AddressDTO expectedDTO = _mapper.Map <AddressDTO>(address);
//set mockRepo return for Add action
_mockRepository.Setup(repo => repo.AddTAsync(address)).ReturnsAsync(1);
//set repo return for getting the newly created object
_mockRepository.Setup(repo => repo.GetOneByAsync(ad => ad.Client_Id == address.Client_Id &&
ad.StreetNumber == address.StreetNumber &&
ad.City == address.City)).ReturnsAsync(address);
//instantiate the controller, passing the repo object
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
var actionResult = await controller.AddAddressAsync(address);
//Get the int result from the posted ActionResult
var createdResult = actionResult.Result as CreatedResult;
var statusCode = createdResult.StatusCode;
AddressDTO actualDto = createdResult.Value as AddressDTO;
//Assert the result
Assert.NotNull(actionResult);
//Validate returned status code
Assert.Equal(201, statusCode);
//Validate the result
actualDto.Should().BeEquivalentTo(expectedDTO, options => options.ComparingByMembers <AddressDTO>());
}
public async void AddAddressAsync_Returns_NotFound_404_When_Create_With_null_Address()
{
//Configure Repository Mock
_mockRepository.Setup(repo => repo.AddTAsync(null)).ReturnsAsync(0);
string expectedMessage = "No Address was created";
//instantiate the controller, and call the method
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Create Custom ControllerContext and add it to Controller for logging in the Controller in case of error
controller.ControllerContext = new ControllerContextModel();
//Call the SUT method - returns ActionResult<BillableActivity> type
var actionResult = await controller.AddAddressAsync(null);
//Assert the result
Assert.NotNull(actionResult);
var result = actionResult.Result as NotFoundObjectResult;
var statusCode = result.StatusCode;
var message = result.Value;
//Assert message
Assert.Equal(expectedMessage, message);
//Assert StatusCode
Assert.Equal(404, statusCode);
}
public async void GetAddresses()
{
// create a list of addresses to return
var listOfAddresses = new List <Address>();
listOfAddresses.Add(new Address()
{
AddressId = 1,
Street = "123 Easy St",
City = "New York",
State = "NY",
Country = "USA",
Zip = "12345"
});
addressRepo.Setup(x => x.ToListAsync()).ReturnsAsync(listOfAddresses);
// when ToListAsync is called, return this listOfaddresses instead (in order to test without dependencies)
var addressesController = new AddressesController(addressRepo.Object);
var result = await addressesController.GetAddress();
var valuesOfresult = (result.Result as OkObjectResult).Value;
valuesOfresult.Should().BeEquivalentTo(listOfAddresses);
addressesController.Should().NotBeNull();
/* var mockRepo = AddressRepo;
* mockRepo.Setup(ar => ar.FindAsyncAsNoTracking(1)).ReturnsAsync(Address)null);
*
* await subject.GetAddress(); // gets all addresses from the address controller action method
*
* mockRepo.Verify(ar => ar.ToListAsync(), Times.Exactly(1));*/
}
public async void GetAddressByIdWithContactsAsync_Returns_One_Address_With_Related_Contacts(int id)
{
//get the first Address and its contacts
var address = _addresses.FirstOrDefault <Address>();
address.Contacts = ContactsData.getTestContacts().Where(co => co.Address_Id == id) as ICollection <Contact>;
var expectedDto = _mapper.Map <AddressWithContactsDTO>(address);
//specify the mockRepo return
_mockRepository.Setup(repo => repo.GetOneByWithRelatedDataAsync(ad => ad.Id == id, ad => ad.Contacts)).ReturnsAsync(address);
//instantiate the controller, and call the method
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
var actionResult = await controller.GetAddressByIdWithContactsAsync(id);
//Assert the result
Assert.NotNull(actionResult);
//convert ActionResult to OkObjectResult to get its Value
var result = Assert.IsType <OkObjectResult>(actionResult.Result);
//get the ObjectResult.Value
var actualDto = result.Value as AddressWithContactsDTO;
//use FluentAssertions to compare Reference types
actualDto.Should().BeEquivalentTo(expectedDto, options => options.ComparingByMembers <AddressDTO>());
}
public async void GetAddressesByClientIdAsync_Returns_All_Addresses_for_One_Client(int client_id)
{
//gets all BillableActivities for one employee
var _addressesForClient = _addresses.Where(ad => ad.Client_Id == client_id);
IEnumerable <AddressDTO> expectedDtos = _mapper.Map <IEnumerable <AddressDTO> >(_addressesForClient);
//Setup repository
_mockRepository.Setup(repo => repo.GetByAsync(co => co.Client_Id == client_id))
.ReturnsAsync(_addressesForClient);
//instantiate System Under Test
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);;
//call SUT method
var actionResult = await controller.GetAddressesByClientIdAsync(client_id);
//Assert results
Assert.NotNull(actionResult);
//Assert object in actionresult
var result = Assert.IsType <OkObjectResult>(actionResult.Result);
var actualAddresses = (IEnumerable <AddressDTO>)(result.Value);
IEnumerable <AddressDTO> actualDtos = _mapper.Map <IEnumerable <AddressDTO> >(actualAddresses);
//use FluentAssertions to compare Collections of Reference types
actualDtos.Should().BeEquivalentTo(expectedDtos, options => options.ComparingByMembers <AddressDTO>());
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Post(It.IsAny <AddressDtoCreate>())).ReturnsAsync(
new AddressDtoCreateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
CreatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var addressDtoCreate = new AddressDtoCreate
{
Street = "Rua Morom"
};
var result = await _controller.Post(addressDtoCreate);
Assert.True(result is CreatedResult);
var resultValue = ((CreatedResult)result).Value as AddressDtoCreateResult;
Assert.NotNull(resultValue);
Assert.Equal(addressDtoCreate.Street, resultValue.Street);
}
public async void DeleteAddressAsync_Deletes_One_Address_And_Returns_Number_Of_Deletions(int id)
{
//declare an Address
Address address = _addresses.FirstOrDefault();
//set repo return for getting the object to delete
_mockRepository.Setup(repo => repo.GetOneByAsync(ad => ad.Id == id))
.ReturnsAsync(address);
//set mockRepo return for Delete action
_mockRepository.Setup(repo => repo.DeleteTAsync(address)).ReturnsAsync(1);
//instantiate the controller, passing the repo object
var controller = new AddressesController(_mockRepository.Object, _mapper, _logger);
//Call the controller method
var actionResult = await controller.DeleteAddressAsync(id);
//Get the int result
var okObjectResult = actionResult.Result as OkObjectResult;
var statusCode = okObjectResult.StatusCode;
int actualDeleted = (int)okObjectResult.Value;
//Assert the result
Assert.NotNull(actionResult);
//Validate StatusCode
Assert.Equal(200, statusCode);
//Validate the number of Addresses deleted
Assert.Equal(1, actualDeleted);
}
public void TestExist_ValidAddress_ShouldSuccess(string value)
{
int addressId = int.Parse(value);
AddressesController controller = new AddressesController(_context);
bool isExist = controller.AddressExists(addressId);
Assert.Equal("True", isExist.ToString());
}
public AddressesControllerTests()
{
_mailingService = new Mock <IMailingService>();
MockMailingService();
_controller = new AddressesController(_context, _mailingService.Object);
MockHttpContext();
MockUrlHelper();
}
public void ValidAddressId_Accepted(string value)
{
int addressId = int.Parse(value);
AddressesController controller = new AddressesController(_context);
bool isExist = controller.AddressExists(addressId);
Assert.Equal("True", isExist.ToString());
}
public void Setup()
{
begin = DateTime.Now;
client = DataMother.CreateTestClientWithUser();
user = client.Users.First();
controller = new AddressesController();
PrepareController(controller, "Addresses", "Add");
controller.DbSession = session;
}
public void Delete_Test()
{
//arrange
AddressesController ac = new AddressesController();
//Act
var result = ac.DeleteAddress(_aID) as OkNegotiatedContentResult <Address>;
//Assert
Assert.AreEqual("Brampton", result.Content.City);
}
public void Address_Get_By_Id()
{
var mockrepo = SetupMockRepo();
var controller = new AddressesController(mockrepo.Object);
var apiResponse = controller.Get(1);
var okResult = apiResponse.Should().BeOfType <OkObjectResult>().Subject;
var account = okResult.Value.Should().BeAssignableTo <Account>().Subject;
//response expects object collection
account.Id.Should().Be(1);
}
public void Addresses_Get_All()
{
var mockrepo = SetupMockRepo();
var controller = new AddressesController(mockrepo.Object);
var apiResponse = controller.GetList();
var okResult = apiResponse.Should().BeOfType <OkObjectResult>().Subject;
var accounts = okResult.Value.Should().BeAssignableTo <IEnumerable <Account> >().Subject;
//response expects object collection
accounts.Count().Should().Be(2);
}
public async Task Delete_Get_Abnormal1()
{
// Arrange
int?testAddressId = null;
var mockRepo = new Mock <IAddressesRepository>();
var controller = new AddressesController(mockRepo.Object);
// Act
var result = await controller.Delete(testAddressId);
// Assert
var badRequestResult = Assert.IsType <NotFoundResult>(result);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Delete()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Delete(It.IsAny <Guid>())).ReturnsAsync(false);
_controller = new AddressesController(serviceMock.Object);
_controller.ModelState.AddModelError("Id", "Formato inválido.");
var result = await _controller.Delete(default(Guid));
Assert.True(result is BadRequestObjectResult);
}
public void GetReturnsListOfAddresses()
{
//Arrange
var moq = new Mock <IAddressRepository>();
moq.Setup(m => m.Get()).Returns(Task.FromResult(new List <Address>() as IEnumerable <Address>));
AddressesController controller = new AddressesController(moq.Object);
//Act
var result = controller.Get().Result;
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <Address>));
}
