public AutoDto InsertAuto(AutoDto autoDto)
{
Auto auto = autoDto.ConvertToEntity();
autoReservationBusinessComponent.InsertAuto(auto);
return(auto.ConvertToDto());
}
public async Task UpdateAutoWithOptimisticConcurrencyTest()
{
// arrange
AutoDto auto1 = _target.Get(new AutoRequest {
Id = 2
});
auto1.Marke = "VW Polo";
auto1.Tagestarif = 135;
AutoDto auto2 = _target.Get(new AutoRequest {
Id = 2
});
auto2.Marke = "VW Tiguan";
auto2.Tagestarif = 150;
//act
_target.Update(auto1);
RpcException exception = Assert.Throws <RpcException>(() => _target.Update(auto2));
Assert.Equal(StatusCode.Aborted, exception.StatusCode);
Assert.Equal("Status(StatusCode=Aborted, Detail=\"Conccurency Exception.\")", exception.Message);
//assert
AutoDto auto = _target.Get(new AutoRequest {
Id = 2
});
CompareAutoDtos(auto, 2, "VW Polo", 135, AutoKlasse.Mittelklasse, 0);
}
public static AutoDto ConvertToDto(this Auto entity)
{
if (entity == null)
{
return(null);
}
AutoDto dto = new AutoDto
{
Id = entity.Id,
Marke = entity.Marke,
Tagestarif = entity.Tagestarif,
RowVersion = ByteString.CopyFrom(entity.RowVersion ?? new byte[0]),
};
if (entity is StandardAuto)
{
dto.AutoKlasse = AutoKlasse.Standard;
}
if (entity is MittelklasseAuto)
{
dto.AutoKlasse = AutoKlasse.Mittelklasse;
}
if (entity is LuxusklasseAuto auto)
{
dto.AutoKlasse = AutoKlasse.Luxusklasse;
dto.Basistarif = auto.Basistarif;
}
return(dto);
}
public void InsertReservationTest()
{
Target.GetAuto(1);
CallbackSpy.WaitForAnswer();
AutoDto auto = CallbackSpy.AutoSpy.First();
CallbackSpy.AutoSpy.Clear();
Target.GetKunde(1);
CallbackSpy.WaitForAnswer();
KundeDto kunde = CallbackSpy.KundeSpy.First();
CallbackSpy.KundeSpy.Clear();
ReservationDto reservation = new ReservationDto {
Auto = auto, Bis = DateTime.Now.AddDays(1), Von = DateTime.Now.AddDays(-1), Kunde = kunde, ReservationsNr = 9999
};
Target.AddReservation(reservation);
CallbackSpy.WaitForAnswer();
ReservationDto insertedReservation = CallbackSpy.ReservationSpy.First();
Assert.AreEqual(insertedReservation.ReservationsNr, 4);
Assert.AreEqual(insertedReservation.Von, reservation.Von);
Assert.AreEqual(insertedReservation.Bis, reservation.Bis);
}
public void CheckAvailabilityIsTrueTest()
{
Target.GetAuto(2);
CallbackSpy.WaitForAnswer();
AutoDto auto = CallbackSpy.AutoSpy.First();
Target.GetKunde(3);
CallbackSpy.WaitForAnswer();
KundeDto kunde = CallbackSpy.KundeSpy.First();
CallbackSpy.AutoSpy.Clear();
CallbackSpy.KundeSpy.Clear();
ReservationDto reservation = new ReservationDto {
Auto = auto, Kunde = kunde, Von = new DateTime(2017, 11, 28), Bis = new DateTime(2018, 01, 01)
};
Target.IsAutoAvailable(reservation);
CallbackSpy.WaitForAnswer();
bool?isAvailable = CallbackSpy.IsAvailable;
Assert.IsTrue(isAvailable ?? false);
CallbackSpy.IsAvailable = null;
}
public async Task UpdateAutoWithOptimisticConcurrencyTest()
{
var autoToInsert = new AutoDto
{
Marke = "Opel", Tagestarif = 50, AutoKlasse = AutoKlasse.Mittelklasse
};
const int newTagestarifA = 100;
const int newTagestarifB = 10;
var autoAToUpdate = await _target.InsertAutoAsync(autoToInsert);
autoAToUpdate.Tagestarif = newTagestarifA;
await _target.UpdateAutoAsync(autoAToUpdate);
var autoBToUpdate = autoAToUpdate;
autoBToUpdate.Tagestarif = newTagestarifB;
try
{
await _target.UpdateAutoAsync(autoBToUpdate);
}
catch (RpcException e)
{
Assert.Equal(StatusCode.Aborted, e.StatusCode);
}
}
public void UpdateAutoTest()
{
AutoDto tempAutoDto = Target.GetAutoById(1);
tempAutoDto.Marke = "Mini";
Assert.AreEqual("Mini", Target.UpdateAuto(tempAutoDto).Marke);
}
//Auto updaten:
private void AutoSaveButton_OnClick(object sender, RoutedEventArgs e)
{
try
{
AutoDto targetAutoToUpdate = GetSelectedAuto();
AutoDto newAuto = loadFromAutoForm();
//totaler gurkencode, ist mir aber egal
//Die Idee mit einem Member "selectedCar" war schon nicht schlecht, aber eig müsste man eh ein Binding machen...
targetAutoToUpdate.AutoKlasse = newAuto.AutoKlasse;
targetAutoToUpdate.Marke = newAuto.Marke;
targetAutoToUpdate.Basistarif = newAuto.Basistarif;
targetAutoToUpdate.Tagestarif = newAuto.Tagestarif;
AutoDto updatedAuto = Model.service.UpdateAuto(targetAutoToUpdate);
//Property Changed Dings... DTO müsste INotifyPropertyChanged implementieren oder sowas --> Done
//Mache es hier the simple way. Wie gesagt, sehr gurkig.
Model.Autos.Remove(targetAutoToUpdate);
Model.Autos.Add(updatedAuto);
}
catch (FormatException ex)
{
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK);
}
catch (FieldAccessException ex)
{
MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK);
}
catch (FaultException <OptimisticConcurrencyFault> ex)
{
MessageBox.Show(ex.Detail.Message, "Fehler", MessageBoxButton.OK);
}
}
////////////////////////////*****RESER*****//////////////////////////////////////////////////////////////////////////////
// Reads from From and returns a new Dto
private ReservationDto loadFromReservationForm()
{
string vonDatText = ResVon.Text;
string bisDatText = ResBis.Text;
DateTime vonDat;
DateTime bisDat;
bool success = DateTime.TryParse(vonDatText, out vonDat);
if (!success)
{
throw new FormatException("Meine Intelligenz reicht nicht aus, das VON-Datum zu lesen.");
}
success = DateTime.TryParse(bisDatText, out bisDat);
if (!success)
{
throw new FormatException("BIS Datum.... isch en Chabis! Hmm, lecker Kabis.");
}
KundeDto k = ResKunde.SelectionBoxItem as KundeDto;
AutoDto a = ResAuto.SelectionBoxItem as AutoDto;
return(new ReservationDto
{
Von = vonDat,
Bis = bisDat,
Kunde = k,
Auto = a
});
}
public void AddAuto(AutoDto auto)
{
WriteActualMethod();
var autoEntity = DtoConverter.ConvertToEntity(auto);
autoManager.Add(autoEntity);
}
private void loadIntoAutoForm(AutoDto car)
{
AutoMarke.Text = car.Marke;
AutoklasseTextbox.Text = car.AutoKlasse.ToString();
AutoTagestarif.Text = car.Tagestarif.ToString();
AutoBasistarif.Text = car.Basistarif.ToString();
}
public AutoDto UpdateAuto(AutoDto autoDto)
{
WriteActualMethod();
return(handlingOptimisticConcurrencyException <AutoDto>("UpdateAuto",
() => AutoManager.UpdateAuto(autoDto.ConvertToEntity()).ConvertToDto()
));
}
private static Auto GetAutoInstance(AutoDto dto)
{
if (dto.AutoKlasse == AutoKlasse.Standard) { return new StandardAuto(); }
if (dto.AutoKlasse == AutoKlasse.Mittelklasse) { return new MittelklasseAuto(); }
if (dto.AutoKlasse == AutoKlasse.Luxusklasse) { return new LuxusklasseAuto(); }
throw new NotImplementedException("Unknown AutoDto implementation.");
}
public void Test_UpdateAutoWithOptimisticConcurrency()
{
AutoDto originalAuto1 = Target.GetAuto(1);
AutoDto originalAuto2 = Target.GetAuto(1);
AutoDto auto1 = new AutoDto
{
AutoKlasse = originalAuto1.AutoKlasse,
Basistarif = originalAuto1.Basistarif,
Id = originalAuto1.Id,
Marke = originalAuto1.Marke,
Tagestarif = originalAuto1.Tagestarif + 10
};
AutoDto auto2 = new AutoDto
{
AutoKlasse = originalAuto2.AutoKlasse,
Basistarif = originalAuto2.Basistarif,
Id = originalAuto2.Id,
Marke = originalAuto2.Marke,
Tagestarif = originalAuto2.Tagestarif + 20
};
Target.UpdateAuto(auto1, originalAuto1);
Target.UpdateAuto(auto2, originalAuto2);
}
public void DeleteAutoTest()
{
AutoDto testAuto = service.getCarById(1);
service.removeCar(testAuto);
Assert.IsNull(service.getCarById(1));
}
public async Task UpdateAutoWithOptimisticConcurrencyTest()
{
var autoToInsert = new AutoDto
{
Marke = "Skoda Octavia", Tagestarif = 50, AutoKlasse = AutoKlasse.Mittelklasse
};
const int newTagestarifA = 55;
const int newTagestarifB = 45;
var autoToUpdateA = await _target.InsertAutoAsync(autoToInsert);
autoToUpdateA.Tagestarif = newTagestarifA;
await _target.UpdateAutoAsync(autoToUpdateA);
var autoToUpdateB = autoToUpdateA;
autoToUpdateB.Tagestarif = newTagestarifB;
try
{
await _target.UpdateAutoAsync(autoToUpdateB);
}
catch (RpcException e)
{
Assert.Equal(StatusCode.Aborted, e.StatusCode);
}
}
public bool isCarAvailable(ReservationDto reservation, AutoDto auto)
{
WriteActualMethod();
ReservationManager reservationManager = new ReservationManager();
return(reservationManager.IsCarAvailable(DtoConverter.ConvertToEntity(reservation), DtoConverter.ConvertToEntity(auto)));
}
public AutoDto InsertAuto(AutoDto auto)
{
WriteActualMethod();
AutoManager am = new AutoManager();
return(am.Insert(auto.ConvertToEntity()).ConvertToDto());
}
public void DeleteAutoTest()
{
AutoDto auto = Target.GetAutoById(1);
Target.DeleteAuto(auto);
Assert.IsNull(Target.GetAutoById(1));
}
public AutoDto DeleteAuto(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = DtoConverter.ConvertToEntity(autoDto);
return(DtoConverter.ConvertToDto(autoReservationBusinessComponent.DeleteAuto(auto)));
}
public static AutoDto ConvertToDto(this Auto entity)
{
if (entity == null)
{
return(null);
}
AutoDto dto = new AutoDto
{
Id = entity.Id,
Brand = entity.Brand,
DailyRate = entity.DailyRate,
RowVersion = entity.RowVersion
};
if (entity is StandardAuto)
{
dto.AutoClass = AutoKlasse.StandardAuto;
}
if (entity is MittelklasseAuto)
{
dto.AutoClass = AutoKlasse.MittelklasseAuto;
}
if (entity is LuxusklasseAuto)
{
dto.AutoClass = AutoKlasse.LuxusklasseAuto;
dto.BaseRate = ((LuxusklasseAuto)entity).BaseRate;
}
return(dto);
}
public void UpdateAutoTest()
{
TestEnvironmentHelper.InitializeTestData();
AutoDto auto = new AutoDto
{
Marke = "Renault Clio",
AutoKlasse = AutoKlasse.Standard,
Tagestarif = 65
};
int autoId = Target.InsertAuto(auto);
Assert.AreNotEqual(0, autoId);
AutoDto org = Target.GetAutoById(autoId);
AutoDto mod = Target.GetAutoById(autoId);
mod.Marke = "Fiat 500";
Target.UpdateAuto(mod, org);
AutoDto result = Target.GetAutoById(autoId);
Assert.AreEqual(mod.Id, result.Id);
Assert.AreEqual(mod.Marke, result.Marke);
Assert.AreEqual(mod.AutoKlasse, result.AutoKlasse);
Assert.AreEqual(mod.Tagestarif, result.Tagestarif);
Assert.AreEqual(mod.Basistarif, result.Basistarif);
}
public void InsertReservationWithInvalidDateRangeTest()
{
Target.GetAuto(1);
CallbackSpy.WaitForAnswer();
AutoDto auto = CallbackSpy.AutoSpy.First();
CallbackSpy.AutoSpy.Clear();
Target.GetKunde(1);
CallbackSpy.WaitForAnswer();
KundeDto kunde = CallbackSpy.KundeSpy.First();
CallbackSpy.KundeSpy.Clear();
ReservationDto reservation = new ReservationDto {
Auto = auto, Bis = DateTime.Now.AddSeconds(1), Von = DateTime.Now, Kunde = kunde, ReservationsNr = 9999
};
Target.AddReservation(reservation);
CallbackSpy.WaitForAnswer();
string ex = CallbackSpy.ExceptionSpy;
Assert.AreEqual("Reservation must be at 24 hours long", ex);
CallbackSpy.ExceptionSpy = null;
}
public void DeleteAutoTest()
{
AutoDto zulöschendesAuto = Target.GetAutoById(3);
Target.DeleteAuto(zulöschendesAuto);
Assert.IsNull(Target.GetAutoById(3));
}
public void CheckAvailabilityIsFalseTest()
{
Target.GetAuto(1);
CallbackSpy.WaitForAnswer();
AutoDto auto = CallbackSpy.AutoSpy.First();
Target.GetKunde(2);
CallbackSpy.WaitForAnswer();
KundeDto kunde = CallbackSpy.KundeSpy.First();
CallbackSpy.AutoSpy.Clear();
CallbackSpy.KundeSpy.Clear();
Target.GetReservation(1);
CallbackSpy.WaitForAnswer();
ReservationDto reservation = CallbackSpy.ReservationSpy.First();
CallbackSpy.ReservationSpy.Clear();
ReservationDto newRes = new ReservationDto {
Auto = auto, Kunde = kunde, Von = reservation.Von, Bis = reservation.Bis
};
Target.IsAutoAvailable(newRes);
CallbackSpy.WaitForAnswer();
bool?isAvailable = CallbackSpy.IsAvailable;
Assert.IsFalse(isAvailable ?? true);
CallbackSpy.IsAvailable = null;
}
public void InsertAutoTest()
{
AutoDto auto = new AutoDto("Fiat Punto", 50, AutoKlasse.Standard);
Target.InsertAuto(auto);
Assert.True(Target.ReadAutoDtos().Exists(e => e.Equals(auto)));
}
public static AutoDto ConvertToDto(this Auto auto)
{
if (auto == null)
{
return(null);
}
AutoDto dto = new AutoDto
{
Id = auto.Id,
Marke = auto.Marke,
Tagestarif = auto.Tagestarif,
};
if (auto is StandardAuto)
{
dto.AutoKlasse = AutoKlasse.Standard;
}
if (auto is MittelklasseAuto)
{
dto.AutoKlasse = AutoKlasse.Mittelklasse;
}
if (auto is LuxusklasseAuto)
{
dto.AutoKlasse = AutoKlasse.Luxusklasse;
dto.Basistarif = ((LuxusklasseAuto)auto).Basistarif;
}
return(dto);
}
public void UpdateAutoTest()
{
AutoDto auto = Target.GetCar(2);
auto.Basistarif = 666;
Assert.True(Target.UpdateCar(auto));
}
public static AutoDto ConvertToDto(this Auto entity)
{
if (entity == null)
{
return(null);
}
AutoDto dto = new AutoDto
{
Id = entity.Id,
Marke = entity.Marke,
Tagestarif = entity.Tagestarif,
RowVersion = entity.RowVersion
};
if (entity is StandardAuto)
{
dto.AutoKlasse = AutoKlasse.Standard;
}
if (entity is MittelklasseAuto)
{
dto.AutoKlasse = AutoKlasse.Mittelklasse;
}
if (entity is LuxusklasseAuto)
{
dto.AutoKlasse = AutoKlasse.Luxusklasse;
dto.Basistarif = ((LuxusklasseAuto)entity).Basistarif;
}
return(dto);
}
public override async Task <AutoDto> DeleteAuto(AutoDto request, ServerCallContext context)
{
var auto = request.ConvertToEntity();
var response = await autoManager.DeleteAuto(auto);
return(response.ConvertToDto());
}
