public ActionResult <bool> Delete([FromBody] DeleteEventDTO request)
{
var command = new DeleteEventCommand(_mapper.Map <Event>(request));
var handler = _commandHandler.Build(command);
return(Ok(handler.Execute()));
}
public async Task <IActionResult> DeleteEvent(int eventId)
{
var deleteEventCommand = new DeleteEventCommand(eventId);
var result = await mediator.Send(deleteEventCommand);
return(StatusCode((int)result.Code, result.Value));
}
public async Task <IActionResult> DeleteConfirmed(int?id, int Id, string returnUrl)
{
if (id == null || id != Id)
{
return(NotFound());
}
var command = new DeleteEventCommand {
Id = Id
};
try
{
await _mediator.Send(command);
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction(nameof(Index)));
}
}
catch (ValidationException ex)
{
ViewData["exception"] = ex.Message;
ErrorViewModel vm = new ErrorViewModel();
return(RedirectToAction("Error", "Home"));
}
}
public async Task <ActionResult> Delete(int id)
{
DeleteEventCommand command = new DeleteEventCommand(id);
await _mediator.Send(command);
return(RedirectToAction("List"));
}
public async Task <ActionResult> Delete(Guid Id)
{
var deleteCommand = new DeleteEventCommand {
EventId = Id
};
await _mediator.Send(deleteCommand);
return(NoContent());
}
public void EventDoesNotExist()
{
var command = new DeleteEventCommand {
EventId = 0
};
var handler = new DeleteEventCommandHandler(Context);
handler.Handle(command);
//TODO: this test needs to be completed to actually test something
}
public IActionResult Delete([FromQuery] DeleteEventCommand command)
{
var commandResult = _mediator.Send(command);
if (commandResult.IsFaulted)
{
return(BadRequest(commandResult.Exception.InnerException.Message));
}
return(Ok(new { message = "Event deleted" }));
}
public async Task Handle_Given_InvalidId_Throws_NotFoundException()
{
// Arrange
var invalidId = 0;
var command = new DeleteEventCommand {
Id = invalidId
};
// Act/Assert
await Assert.ThrowsAsync <NotFoundException>(() => _sut.Handle(command, CancellationToken.None));
}
public void ShouldRequireValidEventId()
{
//arrange
var command = new DeleteEventCommand {
Id = Guid.NewGuid()
};
//assert
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <NotFoundException>();
}
public void EventDoesNotExist()
{
var context = ServiceProvider.GetService <AllReadyContext>();
var command = new DeleteEventCommand {
EventId = 0
};
var handler = new DeleteEventCommandHandler(context);
handler.Handle(command);
//TODO: this test needs to be completed to actually test something
}
public async Task ExistingEvent()
{
var command = new DeleteEventCommand {
EventId = 1
};
var handler = new DeleteEventCommandHandler(Context);
await handler.Handle(command);
var data = Context.Events.Count(_ => _.Id == 1);
Assert.Equal(0, data);
}
public void ShouldNotCallHandleIfEventNotExist()
{
dbSetEvent.Setup(x => x.FindAsync(id)).Returns(null);
context.Setup(x => x.Events).Returns(dbSetEvent.Object);
DeleteEventCommandHandler deleteEventCommandHandler = new DeleteEventCommandHandler(context.Object, stringLocalizer.Object);
DeleteEventCommand deleteEventCommand = new DeleteEventCommand(id);
Func <Task> act = async() => await deleteEventCommandHandler.Handle(deleteEventCommand, new CancellationToken());
act.Should().Throw <NotFoundException>();
}
public async Task <ActionResult <DeleteEventResponse> > DeleteAsync(int id)
{
var command = new DeleteEventCommand();
var request = new DeleteEventRequest()
{
EventID = id
};
command.Data = request;
var response = await Go(command);
return(Ok(response));
}
public void ExistingEvent()
{
var context = ServiceProvider.GetService <AllReadyContext>();
var command = new DeleteEventCommand {
EventId = 1
};
var handler = new DeleteEventCommandHandler(context);
handler.Handle(command);
var data = context.Events.Count(_ => _.Id == 1);
Assert.Equal(0, data);
}
public async Task Handle_Given_ValidId_Deletes_Event()
{
// Arrange
var validId = 1;
var command = new DeleteEventCommand {
Id = validId
};
// Act
await _sut.Handle(command, CancellationToken.None);
// Assert
Assert.Null(_context.Events.Find(validId));
}
public void ShouldNotCallHandleIfNotSavedChanges()
{
dbSetEvent.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Event>(Task.FromResult(new Event {
Id = id
})));
context.Setup(x => x.Events).Returns(dbSetEvent.Object);
context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));
DeleteEventCommandHandler deleteEventCommandHandler = new DeleteEventCommandHandler(context.Object, stringLocalizer.Object);
DeleteEventCommand deleteEventCommand = new DeleteEventCommand(id);
Func <Task> act = async() => await deleteEventCommandHandler.Handle(deleteEventCommand, new CancellationToken());
act.Should().Throw <RestException>();
}
public async Task ShouldCallHandle()
{
dbSetEvent.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Event>(Task.FromResult(new Event {
Id = id
})));
context.Setup(x => x.Events).Returns(dbSetEvent.Object);
context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
DeleteEventCommandHandler deleteEventCommandHandler = new DeleteEventCommandHandler(context.Object, stringLocalizer.Object);
DeleteEventCommand deleteEventCommand = new DeleteEventCommand(id);
var result = await deleteEventCommandHandler.Handle(deleteEventCommand, new CancellationToken());
result.Should().Be(Unit.Value);
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
EventService eventService = new EventService();
switch (commandName)
{
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(eventService);
result = createEvent.Execute(commandParameters);
break;
case "DeleteEvent":
DeleteEventCommand deleteEvent = new DeleteEventCommand(eventService);
result = deleteEvent.Execute(commandParameters);
break;
case "EditEvent":
EditEventCommand editEvent = new EditEventCommand(eventService);
result = editEvent.Execute(commandParameters);
break;
case "ListEvents":
ListEventsCommand listEvents = new ListEventsCommand(eventService);
result = listEvents.Execute(commandParameters);
break;
case "Help":
HelpCommand help = new HelpCommand();
result = help.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand(eventService);
result = exit.Execute(commandParameters);
break;
default:
result = $@"Command {commandName} does not exist. Type ""Help"" to check the available commands.";
break;
}
return(result);
}
public void DeleteEvent_UserExist(
[Frozen] IEventRepository eventRepository,
Event @event,
DeleteEventCommand message,
DeleteEventCommandHandler deleteEventCommandHandler)
{
//Information
A.CallTo(() => eventRepository.GetById(message.EventId)).Returns(@event);
//Act
deleteEventCommandHandler.ExecuteAsync(message);
//Test
A.CallTo(() => eventRepository.Remove(@event))
.MustHaveHappened();
}
public void DeleteEvent_UserDoesNotExist(
[Frozen] IEventRepository eventRepository,
Event @event,
DeleteEventCommand message,
DeleteEventCommandHandler deleteEventCommandHandler)
{
//Information
//Act
deleteEventCommandHandler.ExecuteAsync(message);
//Test
A.CallTo(() => eventRepository.GetById(message.EventId)).Throws(new ArgumentNullException());
A.CallTo(() => eventRepository.Remove(@event))
.MustNotHaveHappened();
}
public void DeleteEvent_EventIsRemoved(
[Frozen] IEventRepository eventRepository,
Event @event,
DeleteEventCommand message,
DeleteEventCommandHandler deleteEventCommandHandler)
{
//Information
@event.EventID = message.EventId;
eventRepository.Add(@event);
var actual = eventRepository.GetById(message.EventId);
//Act
deleteEventCommandHandler.ExecuteAsync(message);
//Test
var expected = eventRepository.GetById(@event.EventID);
Assert.AreNotEqual(expected, actual);
}
public ICommandHandler <DeleteEventCommand, bool> Build(DeleteEventCommand command)
{
return(new DeleteEventCommandHandler(_service, command));
}
public async Task <IActionResult> DeleteEvent(DeleteEventCommand request)
{
return(Ok(await _mediator.Send(request)));
}
public Task <bool> Handle(DeleteEventCommand request, CancellationToken cancellationToken)
{
_eventRepository.Remove(request.EventId);
_unitOfWork.Commit();
return(Task.FromResult(true));
}
