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>)); }