public async Task ReturnsNotFoundWhenEventMissing()
{
_eventRepository
.DeleteEventAsync(Arg.Any <Guid>())
.Returns(false);
var result = await _controller.Delete(Guid.NewGuid());
result.Should().BeOfType <NotFoundResult>();
}
public async void InvalidStatesTestAsync()
{
Mock <IEventService> eventService = new Mock <IEventService>();
Mock <ICategoryService> categoryService = new Mock <ICategoryService>();
var userManager = GetUserManagerMock();
EventsController eventsController = new EventsController(categoryService.Object, eventService.Object, userManager.Object);
Event ev = null;
eventsController.ModelState.AddModelError("invalid", "Invalid model state");
var result = await eventsController.EditEvent(ev);
Assert.NotNull(result);
Assert.False(eventsController.ModelState.IsValid);
result = await eventsController.Create(new CreateEventViewModel());
Assert.NotNull(result);
Assert.False(eventsController.ModelState.IsValid);
result = await eventsController.Create(new CreateEventViewModel());
Assert.NotNull(result);
Assert.False(eventsController.ModelState.IsValid);
result = await eventsController.Delete(TestObjects.Event1.Id);
Assert.NotNull(result);
Assert.False(eventsController.ModelState.IsValid);
Assert.IsAssignableFrom <RedirectToActionResult>(result);
}
public void DeleteMethodShouldReturnBadRequest()
{
var controller = new EventsController();
var result = controller.Delete(null, null) as HttpStatusCodeResult;
Assert.AreEqual(HttpStatusCode.BadRequest, (HttpStatusCode)result.StatusCode);
}
public async Task Delete_Status200OK_ReturnsStatus200OK()
{
// Arrange
_actionManager
.Setup((x) => x.DeleteEventAsync(It.IsAny <int>()))
.ReturnsAsync(StatusCodes.Status200OK);
var expected = StatusCodes.Status200OK;
// Act
var result = await _eventsController.Delete(It.IsAny <int>());
var actual = (result as StatusCodeResult).StatusCode;
// Assert
Assert.AreEqual(expected, actual);
}
public void Delete_DeletesEventObject_True()
{
_newEvent.Save();
ActionResult deletePost = _controller.Delete(_newEvent.GetId());
Assert.IsInstanceOfType(deletePost, typeof(ActionResult));
CollectionAssert.AreEqual(new List <Event> {
}, Event.GetAll());
}
public async Task Delete_given_repository_returns_false_returns_NotFound()
{
var repository = new Mock <IEventRepository>();
var controller = new EventsController(repository.Object);
var delete = await controller.Delete(42);
Assert.IsType <NotFoundResult>(delete);
}
public async Task Delete_given_id_deletes_event()
{
var repository = new Mock <IEventRepository>();
var controller = new EventsController(repository.Object);
await controller.Delete(42);
repository.Verify(s => s.DeleteAsync(42));
}
public async void Delete_ReturnsANotFoundResult(int?eventId)
{
//Arrange
EventsController eventsController = new EventsController(context);
//Act
var result = await eventsController.Delete(eventId);
//Assert
Assert.IsType <NotFoundResult>(result);
}
public async Task Delete_given_valid_returns_NoContent()
{
var repository = new Mock <IEventRepository>();
repository.Setup(s => s.DeleteAsync(42)).ReturnsAsync(true);
var controller = new EventsController(repository.Object);
var delete = await controller.Delete(42);
Assert.IsType <NoContentResult>(delete);
}
public void OrderDetails_Delete()
{
// Arrange
var dbContext = _serviceProvider.GetRequiredService <ApplicationDbContext>();
var controller = new EventsController(dbContext);
// Act
var result = controller.Delete(null);
// Assert
var viewResult = Assert.IsType <HttpNotFoundResult>(result);
Assert.NotNull(viewResult);
// Assert.NotNull(viewResult.ViewData);
//Assert.Same("Your contact page.", viewResult.ViewData["Message"]);
}
public async void DeleteUserHaveNoAccessTest()
{
Mock <IEventService> eventService = new Mock <IEventService>();
Mock <ICategoryService> categoryService = new Mock <ICategoryService>();
var userManager = GetUserManagerMock();
eventService.Setup(item => item.GetEventById(It.IsAny <int>()))
.Returns(TestObjects.Event1);
userManager.Setup(item => item.GetUserAsync(It.IsAny <ClaimsPrincipal>()))
.ReturnsAsync(TestObjects.User2);
userManager.Setup(item => item.IsInRoleAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(false);
EventsController eventsController = new EventsController(categoryService.Object, eventService.Object, userManager.Object);
var result = await eventsController.Delete(TestObjects.Event1.Id);
Assert.IsType <ForbidResult>(result);
}
public async void DeleteUserIsAdminTest()
{
Mock <IEventService> eventService = new Mock <IEventService>();
Mock <ICategoryService> categoryService = new Mock <ICategoryService>();
var userManager = GetUserManagerMock();
eventService.Setup(item => item.GetEventById(It.IsAny <int>()))
.Returns(TestObjects.Event1);
userManager.Setup(item => item.GetUserAsync(It.IsAny <ClaimsPrincipal>()))
.ReturnsAsync(TestObjects.User1);
userManager.Setup(item => item.IsInRoleAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(true);
EventsController eventsController = new EventsController(categoryService.Object, eventService.Object, userManager.Object);
var result = await eventsController.Delete(TestObjects.Event1.Id);
Assert.IsAssignableFrom <RedirectToActionResult>(result);
}
public void DeleteMethodShouldReturnEventToDelete()
{
var eventList = new List <Event>
{
new Event
{
Id = 1, EndDateTime = new DateTime(2014, 1, 12, 12, 0, 0),
EventType = Models.EventType.Single,
StartDateTime = new DateTime(2014, 1, 12, 11, 0, 0),
Users = new List <ApplicationUser> {
new ApplicationUser {
Id = "1"
}
}
},
new Event
{
Id = 2, EndDateTime = new DateTime(2014, 1, 12, 12, 0, 0),
EventType = Models.EventType.Single,
StartDateTime = new DateTime(2014, 1, 12, 11, 0, 0),
Users = new List <ApplicationUser> {
new ApplicationUser {
Id = "1"
}
}
},
new Event
{
Id = 3, EndDateTime = new DateTime(2014, 1, 12, 12, 0, 0),
EventType = Models.EventType.Single,
StartDateTime = new DateTime(2014, 1, 12, 11, 0, 0),
Users = new List <ApplicationUser> {
new ApplicationUser {
Id = "1"
}
}
},
new Event
{
Id = 4, EndDateTime = new DateTime(2014, 1, 12, 12, 0, 0),
EventType = Models.EventType.Double,
StartDateTime = new DateTime(2014, 1, 12, 11, 0, 0),
Users = new List <ApplicationUser> {
new ApplicationUser {
Id = "1"
}
}
},
};
var eventsRepoMock = new Mock <IRepository <Event> >(MockBehavior.Strict);
eventsRepoMock.Setup(x => x.All()).Returns(eventList.AsQueryable());
var uowDataMock = new Mock <IUowData>(MockBehavior.Strict);
uowDataMock.Setup(x => x.Events).Returns(eventsRepoMock.Object);
var controller = new EventsController(uowDataMock.Object);
var viewResult = controller.Delete(4, null) as PartialViewResult;
var model = viewResult.Model as CreateEventViewModel;
Assert.IsNotNull(viewResult, "The result of delete method is null");
Assert.IsNotNull(model, "The model is null.");
Assert.AreEqual(4, model.Id, "The expected event is different.");
Assert.AreEqual(EventType.Double, model.EventType, "EventType is different than expected.");
}
public void Delete()
{
ViewResult result = controller.Delete(1) as ViewResult;
Assert.AreEqual(db.Events.Find(1), result);
}
public void Deletevalid()
{
var valid = (Event)Controller.Delete(1).Model;
Assert.AreEqual(events.ToList()[0], valid);
}
