public void Delete_IdIsInvalid_ReturnsHttpNotFound(int id)
{
_countryManagerMock.Setup(c => c.GetById(id)).Returns(_countryList.Find(c => c.Id == id));
var result = _countryController.Delete(id);
Assert.IsInstanceOfType(result, typeof(HttpNotFoundResult));
}
public void Add_Test_Country()
{
countryController.Post(585, new SampleCountry {
Name = "city_test", Population = 150, Surface = 500
});
var temp = countryController.CountryManager.GetAll().Last();
Assert.Equal("city_test", temp.Name);
Assert.Equal(150, temp.Population);
Assert.Equal(500, temp.Surface);
countryController.Delete(585, temp.ID);
}
public void Can_Delete_Valid_Countrys()
{
// Arrange - create a Country
Country prod = new Country {
CountryID = 2, Name = "Test"
};
// Arrange - create the mock repository
Mock <IItemRepository> mock = new Mock <IItemRepository>();
mock.Setup(m => m.Countries).Returns(new Country[]
{
new Country {
CountryID = 1, Name = "P1"
},
prod,
new Country {
CountryID = 3, Name = "P3"
},
}.AsQueryable <Country>());
// Arrange - create the controller
CountryController target = new CountryController(mock.Object);
// Act - delete the product
target.Delete(prod.CountryID);
// Assert - ensure that the repository delete method was
// called with the correct Country
mock.Verify(m => m.DeleteCountry(prod.CountryID));
}
public void Delete_InvalidID_ReturnsNotFoundResult()
{
// Arrange
IDataRepository <Country> mockRepository = Substitute.For <IDataRepository <Country> >();
CountryController countryCont = new CountryController(mockRepository);
// Act
var notFoundResult = countryCont.Delete(68);
// Assert
Assert.IsType <Microsoft.AspNetCore.Mvc.NotFoundObjectResult>(notFoundResult);
}
public void DeleteGet_ValidCountryWithAssociatedDate_CannotDelete()
{
// Arrange - create the controller
CountryController target = new CountryController(mock.Object);
// Act - call the action method
var result = target.Delete(2) as ViewResult;
// Assert - check the result
Assert.AreEqual("CannotDelete", result.ViewName);
Assert.IsInstanceOf(typeof(ViewResult), result);
}
public void DeleteCountry()
{
// Arrange
CountryController controller = new CountryController();
var actResult = controller.Delete(1);
// Act
var result = actResult as OkNegotiatedContentResult <bool>;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Content == true);
}
public void GoodWay_Controller_Delete_Country()
{
var serviceMock = new Mock <ICountriesService>();
serviceMock.Setup(x => x.DeleteById(1))
.Returns(() => true);
var controller = new CountryController(serviceMock.Object);
IActionResult result = controller.Delete(1);
Assert.IsType <OkObjectResult>((ActionResult)result);
}
public void DeleteGet_InvalidCountry()
{
// Arrange - create the controller
CountryController target = new CountryController(mock.Object);
// Act - call the action method
var result = (HttpNotFoundResult)target.Delete(15);
Country Country = mock.Object.Countries.Where(m => m.CountryID == 1500).FirstOrDefault();
// Assert - check the result
Assert.IsInstanceOf(typeof(HttpNotFoundResult), result);
Assert.IsNull(Country);
Assert.AreEqual(404, result.StatusCode);
}
public void DeleteReturnsNotFound()
{
var mock = new Mock <ICountryRepository>();
mock.Setup(s => s.Remove(It.IsAny <CountryDto>()));
mock.Setup(s => s.Find(It.IsAny <Expression <Func <CountryDto, bool> > >()))
.Returns(new List <CountryDto>());
var controller = new CountryController(mock.Object, Mapper);
var result = controller.Delete(1);
Assert.NotNull(result);
Assert.IsType <NotFoundResult>(result);
}
public void Delete_NotExistId_ShouldReturnNotFoundResult()
{
var country1 = new Country {
Id = 3, Name = "usa", Code = "111", Businesses = null
};
mock.Setup(repo => repo.GetAllItems(null)).Returns(listItems.AsQueryable());
mock.Setup(repo => repo.Delete(country1));
var controller = new CountryController(mockChild.Object, mock.Object);
var result = controller.Delete(4);
Assert.IsAssignableFrom <ActionResult <Country> >(result);
Assert.IsType <NotFoundResult>(result.Result);
}
public void Delete_ValidId_ShouldReturnDeletedObject()
{
var country1 = new Country {
Id = 1, Name = "usa", Code = "111", Businesses = null
};
mock.Setup(repo => repo.GetAllItems(null)).Returns(listItems.AsQueryable());
mock.Setup(repo => repo.Delete(country1));
var controller = new CountryController(mockChild.Object, mock.Object);
var result = controller.Delete(1);
Assert.IsAssignableFrom <ActionResult <Country> >(result);
Assert.Equal(country1.Id, result.Value.Id);
}
public void DeleteCountryTest()
{
//Arrange
var mockrep = new Mock <ICountry>();
mockrep.Setup(c => c.Delete(It.IsAny <string>())).Returns(true);
CountryController countryCntlrobject = new CountryController(mockrep.Object);
//Act
var resultActual = countryCntlrobject.Delete("USA");
//Assert
var expected = true;
Assert.AreEqual(resultActual, expected);
}
public async void Delete_Errors()
{
CountryControllerMockFacade mock = new CountryControllerMockFacade();
var mockResult = new Mock <ActionResponse>();
mockResult.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.FromResult <ActionResponse>(mockResult.Object));
CountryController controller = new CountryController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Delete(default(int));
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Delete(It.IsAny <int>()));
}
public void DeleteFailureCountryInTheRepo()
{
var mock = new Mock <ICountryRepository>(MockBehavior.Strict);
// Creating the rules for mock, always send true in this case
mock.As <ICRUDRepository <Country, int, CountryFilter> >().Setup(m => m.Remove(It.IsAny <int>()))
.Returns(Task.FromResult(false));
// Creating the controller which we want to create
CountryController controller = new CountryController(mock.Object);
// configuring the context for the controler
fakeContext(controller);
HttpResponseMessage response = controller.Delete(0).Result;
// the result should say "HttpStatusCode.NotFound"
Assert.AreEqual(response.StatusCode, HttpStatusCode.NotFound);
}
public void Delete_ShouldWork()
{
// Arrange
DbContextOptions <RepositoryContext> options = new MockDBHandler().CountryWithThreeMember().build();
using (var context = new RepositoryContext(options))
{
IDataRepository <Country> mockRepository = new CountryManager(context);
CountryController countryCont = new CountryController(mockRepository);
FilterModel fm = new FilterModel();
//Act
var putResult = countryCont.Delete(2) as OkObjectResult;
var okResult = countryCont.Get(fm);
var retObj = Assert.IsType <ActionResult <PagedCollectionResponse <Country> > >(okResult);
// Assert
Assert.Equal(2, retObj.Value.Items.ToList().Count);
Assert.Equal("Country1", retObj.Value.Items.ToList()[0].Name);
Assert.Equal("Country3", retObj.Value.Items.ToList()[1].Name);
}
}
public void DeleteReturnsOkResultAtSuccess()
{
var mock = new Mock <ICountryRepository>();
mock.Setup(s => s.Remove(It.IsAny <CountryDto>()));
mock.Setup(s => s.CanRemove(It.IsAny <CountryDto>())).Returns(true);
mock.Setup(s => s.Find(It.IsAny <Expression <Func <CountryDto, bool> > >()))
.Returns(new[]
{
new CountryDto()
{
Id = 1, Name = "lala"
}
});
var controller = new CountryController(mock.Object, Mapper);
var result = controller.Delete(1);
Assert.NotNull(result);
Assert.IsType <OkObjectResult>(result);
}
public void Contries()
{
ILogger <CountryController> _testlogger = null;
using (var context = new AppDbContext(options, null))
{
var controller = new CountryController(context, _testlogger);
// Get all
var result = controller.Get();
// Assert
var okResult = Assert.IsAssignableFrom <IEnumerable <Country> >(result);
var pgcount = okResult.ToList().Count;
Assert.Equal(2, pgcount);
// Get by ID
var result1 = controller.Get(1);
var okResult1 = Assert.IsAssignableFrom <Country>(result1);
Assert.Equal("country 1", okResult1.CountryName);
// test update
var pg1 = new Country {
CountryID = 1, CountryName = "country 1 upd"
};
controller.UpdateEntry(pg1);
var result3 = controller.Get(1);
Assert.NotEqual("country 1", result3.CountryName);
Assert.Equal("country 1 upd", result3.CountryName);
// test delete
var result4 = controller.Get(2);
Assert.Equal("country 2", result4.CountryName);
IActionResult result5 = controller.Delete(2);
var viewResult = Assert.IsType <Microsoft.AspNetCore.Mvc.OkResult>(result5);
var result6 = controller.Get(2);
Assert.Null(result6);
}
}
public async Task Delete_Id_Does_Not_Exist()
{
// arrange
var idToDelete = 13;
var countryService = new Mock <ICountryService>(MockBehavior.Strict);
var controller = new CountryController(countryService.Object)
{
TempData = new Mock <ITempDataDictionary>().Object
};
countryService.Setup(s => s.ExistsAsync(idToDelete)).ReturnsAsync(false);
// act
var result = await controller.Delete(idToDelete);
// assert
Assert.IsAssignableFrom <RedirectToActionResult>(result);
var actionName = (result as RedirectToActionResult)?.ActionName;
Assert.True(string.Equals(actionName, nameof(CountryController.Add), System.StringComparison.InvariantCultureIgnoreCase));
countryService.VerifyAll();
}
public void DeleteGet_DefaultCountry_CannotDelete()
{
// Arrange
List <Country> countries = new List <Country>
{
//ID of default country is 1
new Country {
CountryID = 1, CountryName = "Ukraine", Holidays = new List <Holiday>(), Locations = new List <Location>()
}
};
mock.Setup(m => m.Countries).Returns(countries);
CountryController target = new CountryController(mock.Object);
// Act - call the action method
var result = target.Delete(1) as ViewResult;
// Assert - check the result
Assert.AreEqual("CannotDelete", result.ViewName);
Assert.IsInstanceOf(typeof(ViewResult), result);
}
public void DeleteTestReturn200()
{
var result = countryController.Delete(2);
Assert.IsInstanceOf <NoContentResult>(result);
}
public void DeleteShouldRedirectToIndex()
{
c.Delete(1).ShouldBeJson();
A.CallTo(() => s.Delete(1)).MustHaveHappened();
}
public void DeleteShouldReturnView()
{
countryController.Delete(1, "").ShouldBePartialViewResult();
}
public void DeleteShouldReturnView()
{
c.Delete(1, "").ShouldBeViewResult();
}
public void CountryController_Delete_ReturnsPartialView()
{
var delete = _countryController.Delete(new Country());
delete.Should().BeOfType <PartialViewResult>();
}
