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);
}
}
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 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 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 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 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);
}
}
private async Task CreateVehicleWithImageAsync(string id)
{
var image = new Bitmap(200, 200, PixelFormat.Format24bppRgb);
var stream = new MemoryStream();
image.Save(stream, ImageFormat.Bmp);
byte[] imageBytes = stream.ToArray();
var model = EntitiesFactory.NewModel().Save();
var createVehicle = new CreateVehicle
{
Id = id ?? RandomId.NewId(),
FuelId = EFuel.Flex,
ColorId = EColor.Black,
Year = 2010,
ModelId = model.Id
};
createVehicle.ImageBase64 = Convert.ToBase64String(imageBytes);
await MutationsHandler.Handle(createVehicle);
}
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 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 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);
}
}
