public async Task UpdateReservationWithOptimisticConcurrencyTest()
{
//arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
ReservationDto toUpdate = _target.GetReservation(requestId);
GetCustomerRequest customer1Request = new GetCustomerRequest {
IdFilter = 1
};
CustomerDto customer1 = _kundeClient.GetCustomer(customer1Request);
GetCustomerRequest customer2Request = new GetCustomerRequest {
IdFilter = 2
};
CustomerDto customer2 = _kundeClient.GetCustomer(customer2Request);
//act
toUpdate.Customer = customer1;
Empty emptyUpdate = _target.UpdateReservation(toUpdate);
toUpdate.Customer = customer2;
// assert
Assert.Throws <RpcException>(() => _target.UpdateReservation(toUpdate));
}
public GetReservationResponse GetReservation(GetReservationRequest request)
{
var response = new GetReservationResponse
{
IsSuccessful = false,
Message = ""
};
try
{
var customer = _context.Customers
.FirstOrDefault(x => x.Id == request.CustomerId);
var reservation = _context.TableReservations
.Include(x => x.Customer)
.Where(x => x.Customer.FirstName == customer.FirstName)
.Where(x => x.Customer.LastName == customer.LastName)
.Where(x => x.Customer.Id == customer.Id)
.FirstOrDefault(x => x.Id == request.ReservationId);
if (reservation != null)
{
response.TableReservation = reservation;
response.IsSuccessful = true;
response.Message = "Successfully found reservation.";
}
}
catch (Exception ex)
{
response.IsSuccessful = false;
response.Message = ex.ToString();
}
return(response);
}
public void GetRequestObject()
{
moq::Mock <Reservations.ReservationsClient> mockGrpcClient = new moq::Mock <Reservations.ReservationsClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClientForZoneOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetReservationRequest request = new GetReservationRequest
{
Zone = "zone255f4ea8",
Reservation = "reservationf22d3388",
Project = "projectaa6ff846",
};
Reservation expectedResponse = new Reservation
{
Id = 11672635353343658936UL,
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
Zone = "zone255f4ea8",
CreationTimestamp = "creation_timestamp235e59a1",
Status = Reservation.Types.Status.Deleting,
SpecificReservationRequired = false,
SpecificReservation = new AllocationSpecificSKUReservation(),
Description = "description2cf9da67",
SelfLink = "self_link7e87f12d",
SatisfiesPzs = false,
Commitment = "commitment726158e4",
};
mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
ReservationsClient client = new ReservationsClientImpl(mockGrpcClient.Object, null);
Reservation response = client.Get(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task GetReservationByIdTest()
{
var request = new GetReservationRequest {
Id = 1
};
var response = await _target.GetReservationenByIdAsync(request);
Assert.Equal(1, response.ReservationsNr);
}
public async Task GetReservationByIdWithIllegalIdTest()
{
// arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 123
};
// act
// assert
Assert.Throws <RpcException>(() => _target.GetReservation(requestId));
}
/// <summary>Snippet for GetReservation</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetReservationRequestObject()
{
// Create client
ReservationServiceClient reservationServiceClient = ReservationServiceClient.Create();
// Initialize request argument(s)
GetReservationRequest request = new GetReservationRequest
{
ReservationName = ReservationName.FromProjectLocationReservation("[PROJECT]", "[LOCATION]", "[RESERVATION]"),
};
// Make the request
Reservation response = reservationServiceClient.GetReservation(request);
}
public async Task CheckAvailabilityIsTrueTest()
{
//arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
ReservationDto reservation = _target.GetReservation(requestId);
//act
CheckResponse available = _target.AvailabilityCheck(reservation);
//assert
Assert.True(available.IsValid);
}
public DTO.Reservation Get(GetReservationRequest request)
{
try
{
var reservation = _reservationRepository.FindBy(request.Id);
reservation.ThrowExceptionIfRecordIsNull();
return(_reservationFactory.Execute(reservation));
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
public async Task GetReservationByIdTest()
{
// arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
// act
ReservationDto reply = _target.GetReservation(requestId);
// assert
Assert.Equal("Anna", reply.Customer.FirstName);
Assert.Equal(2, reply.ReservationNr);
}
public async Task GetReservationByIdTest()
{
const int id = 1;
var request = new GetReservationRequest {
IdFilter = id
};
var response = await _target.GetReservationByIdAsync(request);
_testOutputHelper.WriteLine(response.ToString());
Assert.Equal(id, response.ReservationsNr);
Assert.Equal(_von, response.Von);
Assert.Equal(_bis, response.Bis);
_testOutputHelper.WriteLine(response.ToString());
}
public async Task DeleteReservationTest()
{
//arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 1
};
ReservationDto toDelete = _target.GetReservation(requestId);
// act
Empty emptyDelete = _target.DeleteReservation(toDelete);
// assert
Assert.Throws <RpcException>(() => _target.GetReservation(requestId));
}
/// <summary>Snippet for Get</summary>
public void GetRequestObject()
{
// Snippet: Get(GetReservationRequest, CallSettings)
// Create client
ReservationsClient reservationsClient = ReservationsClient.Create();
// Initialize request argument(s)
GetReservationRequest request = new GetReservationRequest
{
Zone = "",
Reservation = "",
Project = "",
};
// Make the request
Reservation response = reservationsClient.Get(request);
// End snippet
}
public override async Task <ReservationDto> GetReservationById(GetReservationRequest request,
ServerCallContext context)
{
ReservationDto response;
try
{
response = await _manager.GetByPrimaryKey(request.IdFilter).ConvertToDto();
}
catch (Exception)
{
throw new RpcException(new Status(StatusCode.Internal, "Internal error occured."));
}
return(response ?? throw new RpcException(new Status(StatusCode.NotFound, "ID is invalid.")));
}
public async Task GetReservationByIdWithIllegalIdTest()
{
const int invalidId = 100;
var request = new GetReservationRequest {
Id = invalidId
};
try
{
await _target.GetReservationenByIdAsync(request);
}
catch (RpcException e)
{
Assert.Equal(StatusCode.NotFound, e.StatusCode);
}
}
public async Task UpdateReservationWithAutoNotAvailableTest()
{
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
ReservationDto toUpdate = _target.GetReservation(requestId);
DateTime from = new DateTime(2020, 1, 19, 0, 0, 0, DateTimeKind.Utc);
DateTime to = new DateTime(2020, 1, 22, 0, 0, 0, DateTimeKind.Utc);
//act
toUpdate.From = from.ToTimestamp();
toUpdate.To = to.ToTimestamp();
// assert
Assert.Throws <RpcException>(() => _target.UpdateReservation(toUpdate));
}
public async Task UpdateReservationWithInvalidDateRangeTest()
{
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 1
};
ReservationDto toUpdate = _target.GetReservation(requestId);
DateTime from = new DateTime(2020, 12, 1, 0, 0, 0, DateTimeKind.Utc);
DateTime to = new DateTime(2020, 12, 3, 0, 0, 0, DateTimeKind.Utc);
//act
toUpdate.From = to.ToTimestamp();
toUpdate.To = from.ToTimestamp();
// assert
Assert.Throws <RpcException>(() => _target.UpdateReservation(toUpdate));
}
public override async Task <ReservationDto> GetReservation(GetReservationRequest request, ServerCallContext context)
{
ReservationDto response = new ReservationDto();
try
{
Reservation data = await _reservationManager.Get(request.IdFilter);
response = data.ConvertToDto();
}
catch (System.Exception e)
{
throw new RpcException(new Status(StatusCode.NotFound, e.Message));
}
return(await Task.FromResult(response));
}
public IActionResult GetReservation(ReserveTableBody body)
{
var request = new GetReservationRequest
{
ReservationId = body.TableId,
CustomerId = body.CustomerId
};
var response = _tableService.GetReservation(request);
if (response.IsSuccessful)
{
return(Ok(response.TableReservation));
}
else
{
return(BadRequest());
}
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetRequestObjectAsync()
{
// Snippet: GetAsync(GetReservationRequest, CallSettings)
// Additional: GetAsync(GetReservationRequest, CancellationToken)
// Create client
ReservationsClient reservationsClient = await ReservationsClient.CreateAsync();
// Initialize request argument(s)
GetReservationRequest request = new GetReservationRequest
{
Zone = "",
Reservation = "",
Project = "",
};
// Make the request
Reservation response = await reservationsClient.GetAsync(request);
// End snippet
}
[ProducesResponseType(200)] //OK
public async Task <ActionResult <GetReservationResponse> > GetReservation(GetReservationRequest reservationNumber)
{
_logger.LogInformation(nameof(GetReservation), "Logging GetReservation");
if (ModelState.IsValid)
{
var result = await _reservationService.GetReservationAsync(reservationNumber);
_logger.LogInformation(nameof(GetReservation), "End GetReservation");
if (result != null)
{
return(Ok(result));
}
else
{
return(NotFound());
}
}
else
{
_logger.LogWarning(nameof(GetReservation), "Wrong input data");
return(BadRequest());
}
}
public async Task UpdateReservationTest()
{
//arrange
GetReservationRequest requestId = new GetReservationRequest {
IdFilter = 2
};
ReservationDto toUpdate = _target.GetReservation(requestId);
GetCustomerRequest customerRequest = new GetCustomerRequest {
IdFilter = 1
};
CustomerDto customer = _kundeClient.GetCustomer(customerRequest);
//act
toUpdate.Customer = customer;
Empty emptyUpdate = _target.UpdateReservation(toUpdate);
// assert
ReservationDto expected = _target.GetReservation(requestId);
Assert.Equal(1, expected.Customer.Id);
}
public async Task <GetReservationResponse> GetReservationAsync(GetReservationRequest reservationNumber)
{
var reservationEntity = await _context.Reservations
.SingleOrDefaultAsync(r => r.ReservationNumber == reservationNumber.reservationNumber);
if (reservationEntity == null)
{
return(null);
}
reservationEntity.ReservationDetails = _context.ReservationDetails.Where(c => c.ReservationNumber == reservationNumber.reservationNumber).ToList();
GetReservationResponse result = _mapper.Map <GetReservationResponse>(reservationEntity);
string flightItemOld = "";
foreach (var flightItem in reservationEntity.ReservationDetails)
{
if (string.Compare(flightItem.FlightKey, flightItemOld) != 0)
{
var flightToInsert = new ReservationFlightResponse
{
key = flightItem.FlightKey,
passengers = new List <PassengersReservationDetailsResponse>()
};
result.flights.Add(flightToInsert);
}
var passengerToInsert = new PassengersReservationDetailsResponse
{
name = flightItem.Name,
bags = flightItem.NumberOfBags,
seat = flightItem.Seat
};
result.flights.Where(c => c.key == flightItem.FlightKey).FirstOrDefault().passengers.Add(passengerToInsert);
flightItemOld = flightItem.FlightKey;
}
return(result);
}
public async stt::Task GetRequestObjectAsync()
{
moq::Mock <Reservations.ReservationsClient> mockGrpcClient = new moq::Mock <Reservations.ReservationsClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClientForZoneOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetReservationRequest request = new GetReservationRequest
{
Zone = "zone255f4ea8",
Reservation = "reservationf22d3388",
Project = "projectaa6ff846",
};
Reservation expectedResponse = new Reservation
{
Id = 11672635353343658936UL,
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
Zone = "zone255f4ea8",
CreationTimestamp = "creation_timestamp235e59a1",
Status = "status5444cb9a",
SpecificReservationRequired = false,
SpecificReservation = new AllocationSpecificSKUReservation(),
Description = "description2cf9da67",
SelfLink = "self_link7e87f12d",
SatisfiesPzs = false,
Commitment = "commitment726158e4",
};
mockGrpcClient.Setup(x => x.GetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Reservation>(stt::Task.FromResult(expectedResponse), null, null, null, null));
ReservationsClient client = new ReservationsClientImpl(mockGrpcClient.Object, null);
Reservation responseCallSettings = await client.GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Reservation responseCancellationToken = await client.GetAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public override async Task <ReservationDto> GetReservationenById(GetReservationRequest request, ServerCallContext context)
{
ReservationDto response = await reservationenManager.GetReservationById(request.Id).ConvertToDto();
return(response ?? throw new RpcException(new Status(StatusCode.NotFound, "ID is invalid.")));
}
public async void GetReservation_ReservationController_Test()
{
////Arrange
var contextMock = InitializeDatabase("GetReservation_ReservationController_Test");
var loggerServiceMock = new Mock <ILogger <ReservationController> >();
var mapperConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MappingProfile());
});
IMapper mapper = mapperConfig.CreateMapper();
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("AppSettings.json");
IConfiguration configuration = configurationBuilder.Build();
var reservationNumberService = new ReservationNumberService();
var reservationService = new ReservationService(contextMock, mapper, reservationNumberService, configuration);
var reservationController = new ReservationController(loggerServiceMock.Object,
mapper,
reservationService);
///Act
ReservationRequest createReservation = new ReservationRequest
{
email = "*****@*****.**",
creditCard = "123456789",
flights = new ReservationFlightRequest[]
{
new ReservationFlightRequest
{
key = "Flight00001",
passengers = new PassengersReservationDetailsRequest[]
{
new PassengersReservationDetailsRequest {
name = "Robert Niro", bags = 3, seat = 1
},
new PassengersReservationDetailsRequest {
name = "John Smith", bags = 3, seat = 2
},
new PassengersReservationDetailsRequest {
name = "Seb True", bags = 3, seat = 3
}
}
},
new ReservationFlightRequest
{
key = "Flight00103",
passengers = new PassengersReservationDetailsRequest[]
{
new PassengersReservationDetailsRequest {
name = "Robert Niro", bags = 3, seat = 1
},
new PassengersReservationDetailsRequest {
name = "John Smith", bags = 3, seat = 2
},
new PassengersReservationDetailsRequest {
name = "Seb True", bags = 3, seat = 3
}
}
}
}
};
// Act on Test
var actionResult = await reservationController.CreateReservationAsync(createReservation);
var content = actionResult.Result as Microsoft.AspNetCore.Mvc.CreatedResult;
var result = content.Value as ReservationResponse;
GetReservationRequest newReservationNumber = new GetReservationRequest()
{
reservationNumber = result.reservationNumber
};
var actionResultGet = await reservationController.GetReservation(newReservationNumber);
var contentGet = actionResultGet.Result as Microsoft.AspNetCore.Mvc.OkObjectResult;
var resultGet = content.Value as GetReservationResponse;
///Assert
Assert.Equal((int)HttpStatusCode.OK, contentGet.StatusCode.Value);
Assert.Equal("AAA001", result.reservationNumber);
}
public async void GetReservation_ReservationService_Test()
{
////Arrange
///
var db = InitializeDatabase("GetReservation_ReservationService_Test");
var loggerServiceMock = new Mock <ILogger <ReservationService> >();
var mapperConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MappingProfile());
});
IMapper mapper = mapperConfig.CreateMapper();
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("AppSettings.json");
IConfiguration configuration = configurationBuilder.Build();
var reservationNumberService = new ReservationNumberService();
var reservationService = new ReservationService(db, mapper, reservationNumberService, configuration);
///Act
ReservationRequest createReservation = new ReservationRequest
{
email = "*****@*****.**",
creditCard = "123456789",
flights = new ReservationFlightRequest[]
{
new ReservationFlightRequest
{
key = "Flight00001",
passengers = new PassengersReservationDetailsRequest[]
{
new PassengersReservationDetailsRequest {
name = "Robert Niro", bags = 3, seat = 1
},
new PassengersReservationDetailsRequest {
name = "John Smith", bags = 3, seat = 2
},
new PassengersReservationDetailsRequest {
name = "Seb True", bags = 3, seat = 3
}
}
},
new ReservationFlightRequest
{
key = "Flight00103",
passengers = new PassengersReservationDetailsRequest[]
{
new PassengersReservationDetailsRequest {
name = "Robert Niro", bags = 3, seat = 1
},
new PassengersReservationDetailsRequest {
name = "John Smith", bags = 3, seat = 2
},
new PassengersReservationDetailsRequest {
name = "Seb True", bags = 3, seat = 3
}
}
}
}
};
// Act on Test
var resultCreation = await reservationService.CreateReservationAsync(createReservation);
GetReservationRequest newReservationNumber = new GetReservationRequest()
{
reservationNumber = resultCreation.reservationNumber
};
var resultGet = await reservationService.GetReservationAsync(newReservationNumber);
// Assert
// The process returns 2 flights.
Assert.Equal(2, resultGet.flights.Count());
}
public Reservation Get(GetReservationRequest request)
{
return(_reservationService.Get(request));
}
