public async Task Test_Events_PartialEditEvent_EditEventOfAnotherUser()
{
// Note that current user is UserMaria
// Arrange: get the "Open Fest" event with owner GuestUser
var openFestEvent = this.testDb.EventOpenFest;
var eventInDbBefore = this.dbContext.Events.FirstOrDefault(x => x.Id == openFestEvent.Id);
var changedName = "OpenFest (New Edition)";
var changedEvent = new PatchEventModel()
{
Name = changedName
};
var requestContent = new StringContent(JsonConvert.SerializeObject(changedEvent), Encoding.UTF8, "application/json");
// Act
var patchResponse = await this.httpClient.PatchAsync(
$"/api/events/{eventInDbBefore.Id}", requestContent);
// Assert user is unauthroized because UserMaria is not the owner of the "Open Fest" event
Assert.AreEqual(HttpStatusCode.Unauthorized, patchResponse.StatusCode);
var patchResponseContent = await patchResponse.Content.ReadAsAsync <ResponseMsg>();
Assert.AreEqual($"Cannot edit event, when not an owner.", patchResponseContent.Message);
this.dbContext = this.testDb.CreateDbContext();
var eventInDbAfter = this.dbContext.Events.Find(openFestEvent.Id);
Assert.AreEqual(eventInDbBefore.Name, eventInDbAfter.Name);
}
public async Task Test_Events_PartialEditEvent_ValidId()
{
// Arrange: get the "Dev Conference" event
var devConfEvent = this.testDb.EventDevConf;
// Create new event model, where only the event name is changed
var changedName = "Dev Conference (New Edition)";
var changedEvent = new PatchEventModel()
{
Name = changedName
};
// Act: send PATCH request with the changed event as StringContent
var requestContent = new StringContent
(JsonConvert.SerializeObject(changedEvent),
Encoding.UTF8,
"application/json");
var patchResponse = await this.httpClient.PatchAsync(
$"/api/events/{devConfEvent.Id}", requestContent);
// Assert
Assert.AreEqual(HttpStatusCode.NoContent, patchResponse.StatusCode);
this.dbContext = this.testDb.CreateDbContext();
var eventInDbAfter = this.dbContext.Events.Find(devConfEvent.Id);
Assert.AreEqual(changedName, eventInDbAfter.Name);
Assert.AreEqual(devConfEvent.Place, eventInDbAfter.Place);
}
public async Task Test_Events_PartialEditEvent_InvalidData()
{
// Arrange: get the "Dev Conference" event
var devConferenceEvent = this.testDb.EventDevConf;
var eventInDbBefore = this.dbContext.Events.Find(devConferenceEvent.Id);
// Create an event model with changed name
// The name is invalid
var changedName = string.Empty;
var changedEvent = new PatchEventModel()
{
Name = changedName
};
var requestContent = new StringContent(JsonConvert.SerializeObject(changedEvent), Encoding.UTF8, "application/json");
// Act: send PATCH request with the changed event
var putResponse = await this.httpClient.PatchAsync(
$"/api/events/{eventInDbBefore.Id}", requestContent);
// Assert a "Bad Request" is returned
Assert.AreEqual(HttpStatusCode.BadRequest, putResponse.StatusCode);
// Assert the event in not edited in the database
this.dbContext = this.testDb.CreateDbContext();
var eventInDbAfter = this.dbContext.Events.Find(devConferenceEvent.Id);
Assert.AreEqual(eventInDbBefore.Name, eventInDbAfter.Name);
}
public IActionResult PatchEvent(int id, PatchEventModel eventModel)
{
var eventExists = this.dbContext.Events.Any(e => e.Id == id);
if (!eventExists)
{
return(NotFound(
new ResponseMsg {
Message = $"Event #{id} not found."
}));
}
var ev = this.dbContext.Events.Find(id);
if (GetCurrentUserId() != ev.OwnerId)
{
return(Unauthorized(
new ResponseMsg {
Message = "Cannot edit event, when not an owner."
}));
}
ev.Name = String.IsNullOrEmpty(eventModel.Name) ? ev.Name : eventModel.Name;
ev.Place = String.IsNullOrEmpty(eventModel.Place) ? ev.Place : eventModel.Place;
ev.Start = eventModel.Start == null ? ev.Start : eventModel.Start.Value;
ev.End = eventModel.End == null ? ev.End : eventModel.End.Value;
if (ev.Start > ev.End)
{
return(BadRequest(
new ResponseMsg {
Message = "End date must be after the start date."
}));
}
ev.Start = ev.Start.AddTicks(-(ev.Start.Ticks % TimeSpan.TicksPerSecond));
ev.End = ev.End.AddTicks(-(ev.End.Ticks % TimeSpan.TicksPerSecond));
ev.TotalTickets = eventModel.TotalTickets == null ? ev.TotalTickets : eventModel.TotalTickets.Value;
ev.PricePerTicket = eventModel.PricePerTicket == null ? ev.PricePerTicket : eventModel.PricePerTicket.Value;
this.dbContext.SaveChanges();
return(NoContent());
}
public void Test_Patch_InvalidId()
{
// Arrange: create an event model
var changedEvent = new PatchEventModel();
var invalidId = -1;
// Act: invoke the controller method with an invalid id and cast the result
var result = this.eventsController.PatchEvent(invalidId, changedEvent) as NotFoundObjectResult;
Assert.IsNotNull(result);
// Assert a "NotFound" result with an error message is returned
Assert.AreEqual((int)HttpStatusCode.NotFound, result.StatusCode);
var resultValue = result.Value as ResponseMsg;
Assert.AreEqual($"Event #{invalidId} not found.", resultValue.Message);
}
public void Test_Patch_ValidId()
{
// Arrange: set UserMaria as currently logged in user
TestingUtils.AssignCurrentUserForController(
this.eventsController, this.testDb.UserMaria);
// Create a new event in the database for partial editing
var newEvent = new Event()
{
Name = "Beach Party" + DateTime.Now.Ticks,
Place = "Ibiza",
Start = DateTime.Now.AddMonths(3),
End = DateTime.Now.AddMonths(3),
TotalTickets = 20,
PricePerTicket = 120.00m,
OwnerId = this.testDb.UserMaria.Id
};
this.dbContext.Add(newEvent);
this.dbContext.SaveChanges();
// Create an event model with changed event name
var changedEvent = new PatchEventModel()
{
Name = "House Party" + DateTime.Now.Ticks
};
// Act: invoke the controller method and cast the result
var result = this.eventsController.PatchEvent(newEvent.Id, changedEvent)
as NoContentResult;
Assert.IsNotNull(result);
// Assert a "NoContent" result with is returned
Assert.AreEqual((int)HttpStatusCode.NoContent, result.StatusCode);
// Assert the event in the database has a changed name
var newEventFromDb = this.dbContext.Events.Find(newEvent.Id);
Assert.AreEqual(newEventFromDb.Name, changedEvent.Name);
}
public async Task Test_Events_PartialEditEvent_InvalidId()
{
// Arrange: create an event model with changed name
var changedName = "Dev Conference (New Edition)";
var changedEvent = new PatchEventModel()
{
Name = changedName
};
var invalidId = -1;
var requestContent = new StringContent(JsonConvert.SerializeObject(changedEvent), Encoding.UTF8, "application/json");
// Act: send a PATCH request with invalid id
var patchResponse = await this.httpClient.PatchAsync(
$"/api/events/{invalidId}", requestContent);
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, patchResponse.StatusCode);
var putResponseContent = await patchResponse.Content.ReadAsAsync <ResponseMsg>();
Assert.AreEqual($"Event #{invalidId} not found.", putResponseContent.Message);
}
public void Test_Patch_UnauthorizedUser()
{
// Arrange: get the "OpenFest" event with owner GuestUser
var openFestEvent = this.testDb.EventOpenFest;
// Set UserMaria as currently logged in user
TestingUtils.AssignCurrentUserForController(this.eventsController, this.testDb.UserMaria);
// Create an event model
var changedEvent = new PatchEventModel();
// Act: invoke the controller method and cast the result
var result = this.eventsController.PatchEvent(openFestEvent.Id, changedEvent) as UnauthorizedObjectResult;
Assert.IsNotNull(result);
// Assert an "Unauthorized" result with an error message is returned
Assert.AreEqual((int)HttpStatusCode.Unauthorized, result.StatusCode);
var resultValue = result.Value as ResponseMsg;
Assert.AreEqual($"Cannot edit event, when not an owner.", resultValue.Message);
}
