public async Task CreateGuestAsync_CreatesGuest_IfGuestDtoCorrect()
{
// Arrange
var mapperConfig = new MapperConfiguration(cfg => cfg.AddProfile <MappingProfile>());
var mapper = mapperConfig.CreateMapper();
var options = await SetupTestDatabaseAsync(_guests);
var httpContextAccessor = new Mock <IHttpContextAccessor>();
var guestRepository = new GuestRepository(new WeddingPlannerDbContext(options, httpContextAccessor.Object));
var guestService = new GuestService(mapper, guestRepository);
// Act
var guestDto = new GuestDto
{
FirstName = "John",
LastName = "Doe"
};
await guestService.CreateAsync(guestDto);
// Assert
using var context = new WeddingPlannerDbContext(options, httpContextAccessor.Object);
var guests = await context.Guests.ToListAsync();
var guest = await context.Guests.SingleAsync(x => x.Id == 4);
guest.Should().NotBeNull();
guest.Id.Should().Be(4);
guest.FirstName.Should().Be("John");
guest.LastName.Should().Be("Doe");
}
public async Task CreateGuestAsync_ReturnErrorResponse_IfExceptionThrown()
{
// Arrange
var mockGuestDto = new GuestDto
{
FirstName = "John",
LastName = "Doe",
Age = 30
};
var mockGuest = new Guest
{
FirstName = "John",
LastName = "Doe",
Age = 30
};
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest);
var mockRepo = new Mock <IGuestRepository>();
mockRepo.Setup(x => x.CreateAsync(mockGuest)).Throws(new Exception("test message"));
// Act
var service = new GuestService(mockMapper.Object, mockRepo.Object);
var result = await service.CreateAsync(mockGuestDto);
// Assert
result.Should().BeOfType <GuestResponse>();
result.Result.Should().BeFalse();
result.Status.Should().Be(ResponseStatus.Error);
result.Item.Should().BeNull();
result.Message.Should().Contain("test message");
}
public async Task <IActionResult> PutGuest(int id, GuestDto guestDto)
{
if (id != guestDto.Id)
{
return(BadRequest());
}
var guest = _mapper.Map <GuestDto, Guest>(guestDto);
_context.Entry(guest).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GuestExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task CreateGuestAsync_ReturnSuccessResponse_ForValidGuestDto()
{
// Arrange
var mockGuestDto = new GuestDto
{
FirstName = "John",
LastName = "Doe",
Age = 30
};
var mockGuest = new Guest
{
FirstName = "John",
LastName = "Doe",
Age = 30
};
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest);
var mockRepo = new Mock <IGuestRepository>();
// Act
var service = new GuestService(mockMapper.Object, mockRepo.Object);
var result = await service.CreateAsync(mockGuestDto);
// Assert
result.Should().BeOfType <GuestResponse>();
result.Result.Should().BeTrue();
result.Status.Should().Be(ResponseStatus.Success);
result.Item.Id.Should().Be(mockGuest.Id);
result.Item.FirstName.Should().Be(mockGuest.FirstName);
result.Item.LastName.Should().Be(mockGuest.LastName);
}
public IHttpActionResult EditGuest(int id, [FromBody] GuestDto guestDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var guestInDb = Context.Guests.SingleOrDefault(g => g.Id == id);
if (guestInDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Mapper.Map(guestDto, guestInDb);
try
{
Context.SaveChanges();
return(Ok(guestInDb));
}
catch (Exception e)
{
Logger.Error(e, e.Message);
return(BadRequest($"Error{e.Message}"));
}
}
public Domain.HotelAggregate.Hotel FindCheapest(GuestDto guest)
{
var _valuesPerHotel = new List <Tuple <Domain.HotelAggregate.Hotel, decimal> >();
var hotels = _hotelRepository.GetAll();
foreach (var hotel in hotels)
{
var reservationSum = 0m;
foreach (var day in guest.DaysOfStaying)
{
var dayType = day.IsWeekend()
? ReservationDayType.Weekend
: ReservationDayType.Weekday;
var reservationTypeByDayAndGuestType = hotel.ReservationValues
.FirstOrDefault(r => r.GuestType == guest.GuestType && r.DayType == dayType);
if (reservationTypeByDayAndGuestType != null)
{
reservationSum += reservationTypeByDayAndGuestType.Value;
}
}
_valuesPerHotel.Add(new Tuple <Domain.HotelAggregate.Hotel, decimal>(hotel, reservationSum));
}
var cheapestHotelInTuple = _valuesPerHotel
.OrderBy(t => t.Item2)
.ThenByDescending(t => t.Item1.Rating)
.FirstOrDefault();
return(cheapestHotelInTuple.Item1);
}
public async Task Register_UserIsUnauthenticated_CreatesGuestUsingMediatorAndReturnsCreatedGuest()
{
var expectedGuestDto = new GuestDto()
{
Id = 5, Username = "******", Password = "******"
};
this.mediatorMock.Setup(m => m.Send(It.IsAny <CreateGuestCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedGuestDto);
var controller = this.GetUnauthenticatedController();
var command = new CreateGuestCommand()
{
Username = "******",
Password = "******"
};
var result = await controller.Register(command).ConfigureAwait(false);
var okObjectResult = Assert.IsAssignableFrom <OkObjectResult>(result);
var user = Assert.IsAssignableFrom <UserDto>(okObjectResult.Value);
Assert.Equal(expectedGuestDto.Id, user.Id);
this.mediatorMock.Verify(m => m.Send(command, CancellationToken.None), Times.Once);
}
public async Task <IActionResult> UpdateGuest(int id, [FromBody] GuestDto guest)
{
try
{
if (id != guest.Id)
{
return(BadRequest("Id to update does not match entity Id"));
}
Entity.Guest entity = await _guestsRepository.Get(id);
if (guest.ConfirmedGuests > entity.TotalGuestsAllowed)
{
return(BadRequest("Cannot have more guests than the maximum allowed for thie guest"));
}
entity.Name = guest.Name;
entity.ConfirmedGuests = guest.ConfirmedGuests;
entity.Partner = guest.Partner;
await _guestsRepository.Update(entity);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public void Validade(GuestDto guest)
{
if (guest == null)
{
throw new ArgumentException("Pessoa informada não encontrada");
}
}
public async Task <IActionResult> CreateGuest([FromBody] GuestDto guest)
{
if (guest == null)
{
return(BadRequest());
}
await _guestService.Add(guest);
return(Created("Created new Guest", guest));
}
public async Task <IActionResult> UpdateGuest([FromBody] GuestDto guest)
{
if (guest == null)
{
return(BadRequest());
}
await _guestService.Update(guest);
return(Ok());
}
public static GuestDto ToDtoGuest(Guest g)
{
GuestDto gu = new GuestDto();
gu.guest_id = g.guest_id;
gu.guest_first_name = g.guest_first_name;
gu.guest_last_name = g.guest_last_name;
gu.guest_email = g.guest_email;
// gu.guest_tz = g.guest_tz;
///....
return(gu);
}
public async Task <ActionResult <GuestDto> > PostGuest(GuestDto guestDto)
{
var guest = _mapper.Map <GuestDto, Guest>(guestDto);
guest.FullName = getFullName(guest.FirstName, guest.MiddleName, guest.LastName);
_context.Guests.Add(guest);
await _context.SaveChangesAsync();
guestDto.Id = guest.Id;
guestDto.FullName = guest.FullName;
return(CreatedAtAction("GetGuest", new { id = guest.Id }, guestDto));
}
public async Task CreateGuest_WhenGuestDtoIsNull_ReturnsNullGuestDto()
{
var client = GetHttpClient();
GuestDto guestDto = null;
var response = await client.PostAsJsonAsync("api/guests", Mapper.Map <Guest, GuestDto>(null));
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNull(guestDto, "Trying to post empty Guest");
}
public static Guest ToDalGuestEdit(GuestDto g)
{
Guest gu = new Guest();
gu.guest_id = g.guest_id;
gu.guest_first_name = g.guest_first_name;
gu.guest_last_name = g.guest_last_name;
gu.guest_email = g.guest_email;
gu.gender = g.gender;
//gu.guest_tz = g.guest_tz;
gu.guest_message_befor = g.guest_message_befor;
gu.guest_message_after = g.guest_message_after;
return(gu);
}
public async Task GetGuest_WhenIdNotValid_ReturnsGuestDto()
{
var id = -1;
var client = GetHttpClient();
GuestDto guestDto = null;
var response = await client.GetAsync("api/guests/" + id);
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNull(guestDto, "Failed request.");
}
public async Task CreateGuest_WhenGuestDtoIsValid_ReturnsGuestDto()
{
var client = GetHttpClient();
GuestDto guestDto = null;
var guestToCreate = MockGuest();
var response = await client.PostAsJsonAsync("api/guests", Mapper.Map <Guest, GuestDto>(guestToCreate));
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNotNull(guestDto);
Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Guest successfully added");
}
public async Task DeleteGuest_WhenCalledWithValidId_ReturnsDeletedObject()
{
var client = GetHttpClient();
GuestDto guestDto = null;
var guestToDelete = GetGuestToDelete().GetAwaiter().GetResult();
var response = await client.DeleteAsync($"api/guests/{guestToDelete.Id}");
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNotNull(guestDto);
Assert.AreEqual(guestToDelete.Id, guestDto.Id, "Guest Id is valid");
Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Object Deleted successfully");
}
public async Task GetGuest_WhenIdIsValid_ReturnsGuestDto()
{
var id = 1;
var client = GetHttpClient();
GuestDto guestDto = null;
var response = await client.GetAsync("api/guests/" + id);
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNotNull(guestDto, "Request success.");
Assert.AreEqual(guestDto.GetType(), typeof(GuestDto), "GuestDto returned.");
}
public static Guest ToDalGuest(GuestDto g)
{
Guest gu = new Guest();
//Random rand = new Random();
//עשיתי מספרים גבוהים כי ךא עובד הבדיקה
gu.guest_id = GuestDal.GetHID() + 1;
gu.guest_first_name = g.guest_first_name;
gu.guest_last_name = g.guest_last_name;
gu.guest_email = g.guest_email;
gu.gender = g.gender;
//gu.guest_tz = g.guest_tz;
gu.guest_message_befor = g.guest_message_befor;
gu.guest_message_after = g.guest_message_after;
return(gu);
}
public GuestDto CreateGuest(GuestDto guestDto)
{
if (ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var guest = Mapper.Map <GuestDto, User_Guest_Detail>(guestDto);
_db.User_Guest_Detail.Add(guest);
_db.SaveChanges();
guestDto.gstID = guest.gstID;
return(guestDto);
}
public async Task EditGuest_WithVaildGuestId_ReturnsUpdatedGuestObject()
{
var client = GetHttpClient();
GuestDto guestDto = null;
var guestToUpdate = MockGuestToDb();
guestToUpdate.FirstName = "UpdatedTestName";
var response = await client.PutAsJsonAsync("api/guests/" + guestToUpdate.Id, Mapper.Map <Guest, GuestDto>(guestToUpdate));
if (response.IsSuccessStatusCode)
{
guestDto = await response.Content.ReadAsAsync <GuestDto>();
}
Assert.IsNotNull(guestDto);
Assert.AreEqual("UpdatedTestName", guestDto.FirstName, "FirstName updated successfully");
Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Returned GuestDto object");
}
public void UpdateGuest(int id, GuestDto guestDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var guestInDb = _db.User_Guest_Detail.SingleOrDefault(c => c.gstID == id);
if (guestInDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Mapper.Map(guestDto, guestInDb);
_db.SaveChanges();
}
public void UpdateGuest(int id, GuestDto guestDto)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var guestInDataBase = _context.Guests.SingleOrDefault(g => g.ID == id);
if (guestInDataBase == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
Mapper.Map(guestDto, guestInDataBase);
_context.SaveChanges();
}
private static Guest GuestMapper(GuestDto guest)
{
return(new Guest()
{
FirstName = guest.FirstName,
LastName = guest.LastName,
Email = guest.Email,
CompanyName = guest.CompanyName,
Nip = guest.Nip,
Id = guest.Id,
Reservation = new Reservation()
{
Price = guest.Price,
ReservationNumber = guest.ReservationNumber,
CheckIn = guest.CheckIn,
CheckOut = guest.CheckOut
}
});
}
public async Task <IActionResult> Create([FromBody] GuestDto model)
{
if (!ModelState.IsValid)
{
_logger.LogWarning("Guest model is not valid.");
return(BadRequest());
}
var response = await _guestService.CreateAsync(model);
if (!response.Result)
{
_logger.LogError($"An error occured during guest creation.");
return(BadRequest(response));
}
_logger.LogInformation($"Guest successfully created: {response.Item.Id}");
return(new OkObjectResult(response));
}
public async Task Create_ReturnsOkResult_WithGuest_ForGivenGuestDto()
{
// Arrange
var mockLogger = new Mock <ILogger <GuestsController> >();
var mockService = new Mock <IGuestService>();
var mockGuest = new GuestDto
{
Id = 1,
FirstName = "John",
LastName = "Doe"
};
var mockItem = new GuestDto
{
Id = 1,
FirstName = "John",
LastName = "Doe"
};
var mockResponse = new GuestResponse(
BaseApiResponse <GuestDto> .CreateSuccessResponse("test message", mockItem));
mockService.Setup(svc => svc.CreateAsync(mockGuest)).ReturnsAsync(mockResponse);
var controller = new GuestsController(mockLogger.Object, mockService.Object);
// Act
var result = await controller.Create(mockGuest);
// Assert
result.Should().BeOfType <OkObjectResult>();
var okObjectResult = (OkObjectResult)result;
okObjectResult.Value.Should().NotBeNull();
okObjectResult.Value.Should().BeOfType <GuestResponse>();
var response = (GuestResponse)okObjectResult.Value;
response.Result.Should().BeTrue();
response.Status.Should().Be(ResponseStatus.Success);
response.Item.Id.Should().Be(mockGuest.Id);
response.Item.FirstName.Should().Be(mockGuest.FirstName);
response.Item.LastName.Should().Be(mockGuest.LastName);
}
public IActionResult AddGuest([FromBody] GuestForCreationDto guest)
{
if (guest.Name == null)
{
return(BadRequest());
}
var newGuest = new GuestDto()
{
Name = guest.Name,
};
GuestsDataStore.Current.Guests.Add(newGuest);
var id = Guid.NewGuid();
// Return response
return(CreatedAtRoute("GetGuest", new {
guestId = id
}, newGuest));
}
public async Task CreateGuestAsync_ReturnErrorResponse_ForNullParam()
{
// Arrange
GuestDto mockGuestDto = null;
Guest mockGuest = null;
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest);
var mockRepo = new Mock <IGuestRepository>();
// Act
var service = new GuestService(mockMapper.Object, mockRepo.Object);
var result = await service.CreateAsync(mockGuestDto);
// Assert
result.Should().BeOfType <GuestResponse>();
result.Result.Should().BeFalse();
result.Status.Should().Be(ResponseStatus.Error);
result.Item.Should().BeNull();
}
// GET: api/guests
public IHttpActionResult Get([FromUri] string name = "Piotr", string city = "")
{
var guests = new List <Guest>();
if (String.IsNullOrEmpty(city))
{
guests = _guestRepo.FindAllByFilter(x => x.FirstName == name).ToList();
}
else
{
guests = _guestRepo.FindAllByFilter(x => x.FirstName == name && x.City == city).ToList();
}
if (!guests.Any())
{
return(NotFound());
}
var guestsDto = GuestDto.CreateManyGuestDto(guests);
return(Ok(guestsDto));
}
