public async void CreateVehicle(
EStatusCode expectedStatus,
CreateVehicle mutation,
bool?withModel = false
)
{
if (withModel.Value)
{
EntitiesFactory.NewModel(id: mutation.ModelId).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var vehicleDb = await MutationsDbContext.Vehicles
.Where(v => v.Id == mutation.Id)
.FirstOrDefaultAsync();
Assert.NotNull(vehicleDb);
Assert.Equal(mutation.Year, vehicleDb.Year);
Assert.Equal(mutation.Board, vehicleDb.Board);
Assert.Equal(mutation.ColorId, vehicleDb.Color);
Assert.Equal(mutation.FuelId, vehicleDb.Fuel);
Assert.Equal(mutation.ModelId, vehicleDb.Model.Id);
}
}
public async void SellVehicle(
EStatusCode expectedStatus,
SellVehicle mutation,
bool?withVehicle = false,
bool?withAnnouncement = false
)
{
if (withAnnouncement.Value)
{
EntitiesFactory.NewAnnouncement(vehicleId: withVehicle.Value ? mutation.Id : null).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var announcementDb = await MutationsDbContext.Announcements
.Where(a => a.VehicleId == mutation.Id)
.FirstOrDefaultAsync();
Assert.NotNull(announcementDb);
Assert.NotNull(announcementDb.DateSale);
Assert.Equal(mutation.DateSale.Value.Date, announcementDb.DateSale.Value.Date);
}
}
public async void LoginUser(
EStatusCode expectedStatus,
LoginUser mutation,
bool?withUser = false,
bool?equalPassword = false
)
{
var user = null as User;
if (withUser.Value)
{
user = EntitiesFactory.NewUser(
login: mutation.Login,
password: equalPassword.Value ? mutation.Password : null
).Save();
}
var(status, result) = await Request.Post <MutationResultTest <LoginResult> >(Uri, mutation);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var loginResult = result.Data;
Assert.NotNull(loginResult);
Assert.NotNull(loginResult.Token);
Assert.False(string.IsNullOrWhiteSpace(loginResult.Token));
Assert.Equal(user.Id, loginResult.Id);
Assert.Equal(user.Name, loginResult.Name);
}
}
public async void GetReservation(
EStatusCode expectedStatus,
GetReservation query
)
{
var reservation = null as Reservation;
if (expectedStatus != EStatusCode.NotFound)
{
reservation = EntitiesFactory.NewReservation(id: query.Id).Save();
}
var(status, result) = await Request.Get <QueryResultOneTest <ReservationDetail> >(new Uri($"{Uri}/{query.Id}"), query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var reservationResult = result.Data;
Assert.NotNull(reservationResult);
var vehicle = reservation.Announcement.Vehicle;
Assert.Equal(reservation.Id, reservationResult.Id);
Assert.Equal(reservation.Contact.Name, reservationResult.ContactName);
Assert.Equal(reservation.Contact.Phone, reservationResult.ContactPhone);
Assert.Equal(reservation.AnnouncementId, reservationResult.AnnouncementId);
}
}
public async Task UpdateModel(
EStatusCode expectedStatus,
UpdateModel mutation,
bool?withModel = false,
bool?withBrand = false
)
{
if (withBrand.Value)
{
EntitiesFactory.NewBrand(id: mutation.BrandId).Save();
}
if (withModel.Value)
{
EntitiesFactory.NewModel(id: mutation.Id, name: mutation.Name).Save();
}
if (expectedStatus == EStatusCode.Conflict)
{
EntitiesFactory.NewModel(name: mutation.Name).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var modelDb = await MutationsDbContext.Models.FindAsync(mutation.Id);
Assert.Equal(mutation.Name, modelDb.Name);
Assert.Equal(mutation.BrandId, modelDb.BrandId);
}
}
public async void ListVehicles(
EStatusCode expectedStatus,
ListVehicles query
)
{
var vehicle = EntitiesFactory.NewVehicle(
brandId: query.BrandId,
modelId: query.ModelId,
fuel: query.FuelId,
color: query.ColorId
).Save();
var(status, result) = await Request.Get <QueryResultListTest <VechicleList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
Assert.NotNull(result.Data);
var vehicleResult = result.Data.FirstOrDefault(v => v.Id == vehicle.Id);
Assert.NotNull(vehicleResult);
Assert.Equal(vehicle.Year, vehicleResult.Year);
Assert.Equal(vehicle.Model.Brand.Name, vehicleResult.BrandName);
Assert.Equal(vehicle.Model.Name, vehicleResult.ModelName);
Assert.NotNull(vehicleResult.ColorHex);
Assert.NotNull(vehicleResult.ColorName);
Assert.NotNull(vehicleResult.FuelName);
}
}
public async void GetVehicle(
EStatusCode expectedStatus,
GetVehicle query
)
{
var vehicle = null as Questor.Vehicle.Domain.Mutations.Vehicles.Entities.Vehicle;
if (expectedStatus != EStatusCode.NotFound)
{
vehicle = EntitiesFactory.NewVehicle(id: query.Id).Save();
}
var(status, result) = await Request.Get <QueryResultOneTest <VehicleDetail> >(new Uri($"{Uri}/{query.Id}"), query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
Assert.NotNull(result.Data);
var vehicleResult = result.Data;
Assert.Equal(vehicle.Year, vehicleResult.Year);
Assert.Equal(vehicle.Model.BrandId, vehicleResult.BrandId);
Assert.Equal(vehicle.Model.Brand.Name, vehicleResult.BrandName);
Assert.Equal(vehicle.ModelId, vehicleResult.ModelId);
Assert.Equal(vehicle.Model.Name, vehicleResult.ModelName);
Assert.Equal(vehicle.Fuel, vehicleResult.FuelId);
Assert.Equal(vehicle.Color, vehicleResult.ColorId);
}
}
public async void CreateReservation(
EStatusCode expectedStatus,
CreateReservation mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewAnnouncement(id: mutation.AnnouncementId).Save();
}
if (expectedStatus == EStatusCode.Conflict)
{
EntitiesFactory.NewContact(phone: mutation.ContactPhone).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var reservationDb = await MutationsDbContext.Reservations
.Where(r => r.Id == mutation.Id)
.FirstOrDefaultAsync();
Assert.NotNull(reservationDb);
Assert.Equal(mutation.AnnouncementId, reservationDb.AnnouncementId);
Assert.Equal(mutation.ContactName, reservationDb.Contact.Name);
Assert.Equal(mutation.ContactPhone, reservationDb.Contact.Phone);
}
}
public async void GetAnnouncement(
EStatusCode expectedStatus,
GetAnnouncement query
)
{
var announcement = null as Announcement;
if (expectedStatus != EStatusCode.NotFound)
{
announcement = EntitiesFactory.NewAnnouncement(id: query.Id).Save();
}
var(status, result) = await Request.Get <QueryResultOneTest <AnnouncementDetail> >(new Uri($"{Uri}/{query.Id}"), query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var announcementResult = result.Data;
Assert.NotNull(announcementResult);
Assert.Equal(announcement.PricePurchase, announcementResult.PricePurchase);
Assert.Equal(announcement.PriceSale, announcementResult.PriceSale);
Assert.Equal(announcement.DateSale, announcementResult.DateSale);
Assert.Equal(announcement.VehicleId, announcementResult.VehicleId);
}
}
public async void CreateAnnouncement(
EStatusCode expectedStatus,
CreateAnnouncement mutation,
bool?withVehicle = false
)
{
if (withVehicle.Value)
{
EntitiesFactory.NewVehicle(id: mutation.VehicleId).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var announcementDb = await MutationsDbContext.Announcements
.Where(a => a.Id == mutation.Id)
.FirstOrDefaultAsync();
Assert.NotNull(announcementDb);
Assert.Equal(mutation.PricePurchase, announcementDb.PricePurchase);
Assert.Equal(mutation.PriceSale, announcementDb.PriceSale);
Assert.Equal(mutation.VehicleId, announcementDb.Vehicle.Id);
Assert.Null(announcementDb.DateSale);
}
}
/// <summary>
/// Metodo HttpResponseMessage: Metodo en el cual se crea el objeto HttpResponseMessage el cual tendra la respusta que dará
/// el servidor
/// </summary>
/// <param name="hTTPVersion">Parametro donde se guarda la version del HTTP</param>
/// <param name="statusCode">Parametro donde se guarda la respuesta que se le da al cliente</param>
/// <param name="reasonPhrase">Parametro adicional para informar el estado de la conexión</param>
/// <param name="headers">Parametro donde se guarda los demas encabezados</param>
/// <param name="messageBody">Mensaje del cuerpo</param>
public HttpResponseMessage(string hTTPVersion, EStatusCode statusCode, string reasonPhrase, Dictionary <EHeaders, string> headers, string messageBody)
{
HTTPVersion = hTTPVersion;
StatusCode = statusCode;
ReasonPhrase = reasonPhrase;
Headers = headers;
MessageBody = messageBody;
}
public MutationResult(
EStatusCode status,
string message = null,
dynamic data = null
)
{
this.Data = data;
this.Status = status;
this.Message = message;
}
public async void ListColors(
EStatusCode expectedStatus,
ListColors query
) {
var (status, result) = await Request.Get<QueryResultListTest<ColorList>>(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success) {
Assert.NotEmpty(result.Data);
var expectedTotal = Enum.GetValues(typeof(EColor)).Length;
Assert.Equal(expectedTotal, result.TotalRows);
}
}
public async void ListAnnouncementSelect(
EStatusCode expectedStatus,
ListAnnouncementSelect query
)
{
var announcement = EntitiesFactory.NewAnnouncement().Save();
var(status, result) = await Request.Get <QueryResultListTest <AnnouncementSelectList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var announcementResult = result.Data.FirstOrDefault(f => f.Id == announcement.Id);
Assert.NotNull(announcementResult);
}
}
public async void ListModels(
EStatusCode expectedStatus,
ListModels query
)
{
var model = EntitiesFactory.NewModel().Save();
var(status, result) = await Request.Get <QueryResultListTest <ModelList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
Assert.NotEmpty(result.Data);
Assert.Contains(result.Data, d => d.Id == model.Id);
}
}
public async void ListModelsSelect(
EStatusCode expectedStatus,
ListModelsSelect query
)
{
var model = EntitiesFactory.NewModel(brandId: query.BrandId).Save();
var(status, result) = await Request.Get <QueryResultListTest <ModelSelectList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var modelResult = result.Data.FirstOrDefault(m => m.Id == model.Id);
Assert.NotNull(modelResult);
Assert.Equal(model.Name, modelResult.Name);
}
}
public async void ListAnnouncementReport(
EStatusCode expectedStatus,
ListAnnouncementReport query
)
{
var announcement = EntitiesFactory.NewAnnouncement(dateSale: DateTime.Now).Save();
var result = await QueriesHandler.Handle(query);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
Assert.NotEmpty(result.Data);
var announcementResult = result.Data.FirstOrDefault(a => a.Id == announcement.Id);
Assert.NotNull(announcementResult);
Assert.Equal(announcement.PriceSale - announcement.PricePurchase, announcementResult.Profit);
Assert.Equal(announcement.Vehicle.Model.Brand.Name, announcementResult.VehicleBrandName);
Assert.Equal(announcement.Vehicle.Model.Name, announcementResult.VehicleModelName);
}
}
public async void DeleteVehicle(
EStatusCode expectedStatus,
DeleteVehicle mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewVehicle(id: mutation.Id).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var exists = await MutationsDbContext.Vehicles.AnyAsync(v => v.Id == mutation.Id);
Assert.False(exists);
}
}
public async Task DeleteBrand(
EStatusCode expectedStatus,
DeleteBrand mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewBrand(id: mutation.Id).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var exists = await MutationsDbContext.Brands.AnyAsync(b => b.Id == mutation.Id);
Assert.False(exists);
}
}
public async void DeleteAnnouncement(
EStatusCode expectedStatus,
DeleteAnnouncement mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewAnnouncement(id: mutation.Id).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var existsAnnouncement = await MutationsDbContext.Announcements.AnyAsync(a => a.Id == mutation.Id);
Assert.False(existsAnnouncement);
}
}
public async void GetVehiclePhoto(
EStatusCode expectedStatus,
GetVehiclePhoto query,
bool?withFile = false
)
{
if (withFile.Value)
{
await CreateVehicleWithImageAsync(query.Id);
}
var(status, file) = await Request.DownloadFile(new Uri($"{Uri}/{query.Id}/photo"), $"{query.Id}.jpg", query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
Assert.NotNull(file);
Assert.True(file.Exists);
}
}
public async Task CreateBrand(
EStatusCode expectedStatus,
CreateBrand mutation
)
{
if (expectedStatus == EStatusCode.Conflict)
{
EntitiesFactory.NewBrand(name: mutation.Name).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var brandDb = await MutationsDbContext.Brands.Where(b => b.Id == mutation.Id).FirstOrDefaultAsync();
Assert.NotNull(brandDb);
Assert.Equal(mutation.Name, brandDb.Name);
}
}
public async void FinishReservation(
EStatusCode expectedStatus,
FinishReservation mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewReservation(id: mutation.Id).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var reservationDb = await MutationsDbContext.Reservations.FindAsync(mutation.Id);
Assert.NotNull(reservationDb.DateSale);
Assert.NotNull(reservationDb.Announcement.DateSale);
}
}
public async void ListReservations(
EStatusCode expectedStatus,
ListReservations query
)
{
var reservation = EntitiesFactory.NewReservation().Save();
var(status, result) = await Request.Get <QueryResultListTest <ReservationList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var reservationResult = result.Data.FirstOrDefault(r => r.Id == reservation.Id);
Assert.NotNull(reservationResult);
Assert.Equal(reservation.Id, reservationResult.Id);
Assert.Equal(reservation.Contact.Name, reservationResult.ContactName);
Assert.Equal(reservation.Contact.Phone, reservationResult.ContactPhone);
Assert.Equal(reservation.Announcement.Vehicle.Model.Brand.Name, reservationResult.VehicleBrandName);
Assert.Equal(reservation.Announcement.Vehicle.Model.Name, reservationResult.VehicleModelName);
}
}
public async void ListAnnouncement(
EStatusCode expectedStatus,
ListAnnouncement query,
bool?exactlyAnnouncement = false
)
{
var vehicle = EntitiesFactory.NewVehicle(
brandId: query.BrandId,
modelId: query.ModelId,
color: query.ColorId,
year: query.Year
).Save();
var announcement = EntitiesFactory.NewAnnouncement(
vehicle: vehicle,
dateSale: query.DateSale?.DateTime
).Save();
var(status, result) = await Request.Get <QueryResultListTest <AnnouncementList> >(Uri, query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
Assert.True(result.TotalRows > 0);
Assert.True(result.Data.Length <= query.Limit);
}
if (exactlyAnnouncement.Value)
{
var listAnnouncement = result.Data.ToList();
var announcementResult = listAnnouncement
.Where(a => a.Id == announcement.Id)
.FirstOrDefault();
Assert.NotNull(announcementResult);
Assert.Equal(announcement.PricePurchase, announcementResult.PricePurchase);
Assert.Equal(announcement.PriceSale, announcementResult.PriceSale);
Assert.Equal(announcement.DateSale.Value.Date, announcementResult.DateSale.Value.Date);
Assert.Equal(announcement.Vehicle.Year, announcementResult.VehicleYear);
Assert.Equal(announcement.Vehicle.Model.Brand.Name, announcementResult.VehicleBrandName);
Assert.Equal(announcement.Vehicle.Model.Name, announcementResult.VehicleModelName);
}
}
public async void GetBrad(
EStatusCode expectedStatus,
GetBrand query
)
{
var brand = null as Brand;
if (expectedStatus != EStatusCode.NotFound)
{
brand = EntitiesFactory.NewBrand(id: query.Id).Save();
}
var(status, result) = await Request.Get <QueryResultOneTest <BrandDetail> >(new Uri($"{Uri}/{query.Id}"), query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var brandResult = result.Data;
Assert.NotNull(brandResult);
Assert.Equal(brand.Id, brandResult.Id);
Assert.Equal(brand.Name, brandResult.Name);
}
}
public async void GetModel(
EStatusCode expectedStatus,
GetModel query
)
{
var model = null as Model;
if (expectedStatus != EStatusCode.NotFound)
{
model = EntitiesFactory.NewModel(id: query.Id).Save();
}
var(status, result) = await Request.Get <QueryResultOneTest <ModelDetail> >(new Uri($"{Uri}/{query.Id}"), query);
Assert.Equal(expectedStatus, status);
if (expectedStatus == EStatusCode.Success)
{
var modelResult = result.Data;
Assert.NotNull(modelResult);
Assert.Equal(model.Id, modelResult.Id);
Assert.Equal(model.Name, modelResult.Name);
}
}
public async Task CreateModel(
EStatusCode expectedStatus,
CreateModel mutation
)
{
if (expectedStatus != EStatusCode.NotFound)
{
EntitiesFactory.NewBrand(id: mutation.BrandId).Save();
}
if (expectedStatus == EStatusCode.Conflict)
{
EntitiesFactory.NewModel(name: mutation.Name).Save();
}
var result = await MutationsHandler.Handle(mutation);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == EStatusCode.Success)
{
var modelDb = await MutationsDbContext.Models.FindAsync(mutation.Id);
Assert.Equal(mutation.Name, modelDb.Name);
}
}
public QueryResult(EStatusCode status, string message)
{
this.Status = status;
this.Message = message;
}
public QueryResultOne(EStatusCode status, string message)
: base(status, message)
{
}
