public void Test_GetKundeById()
{
KundeDto kunde = Target.FindKunde(3);
Assert.AreEqual("Pfahl", kunde.Nachname);
Assert.AreEqual("Martha", kunde.Vorname);
Assert.AreEqual("03.07.1950", kunde.Geburtsdatum.ToShortDateString());
}
public void Test_GetKundeById()
{
KundeDto kunde = Target.GetKunde(1);
Assert.AreEqual(1, kunde.Id);
Assert.AreEqual("Anna", kunde.Vorname);
Assert.AreEqual("Nass", kunde.Nachname);
Assert.AreEqual(new DateTime(1961, 5, 5), kunde.Geburtsdatum);
}
public override async Task <KundeDto> GetById(GetKundeByIdRequest request, ServerCallContext context)
{
KundeManager manager = new KundeManager();
Kunde kunde = await manager.GetById(request.Id);
KundeDto result = kunde.ConvertToDto();
return(result);
}
public void Test_UpdateKundeWithOptimisticConcurrency()
{
KundeDto modified = Target.GetKunde(2);
modified.Vorname = "Lina";
modified.Nachname = "Nadelmann";
Target.UpdateKunde(modified, Target.GetKunde(2));
}
public void InsertKundeTest()
{
KundeDto neuerKunde = new KundeDto {
Id = 5, Geburtsdatum = new DateTime(1996, 11, 21), Vorname = "Hans", Nachname = "Lustig"
};
Target.InsertKunde(neuerKunde);
Assert.AreEqual(Target.GetKundeById(5).Nachname, "Lustig");
}
public KundeDto UpdateKunde(KundeDto modified, KundeDto original)
{
WriteActualMethod();
Kunde modKunde = modified.ConvertToEntity();
Kunde origKunde = original.ConvertToEntity();
return(autoReservationBusinessComponent.Update(modKunde, origKunde).ConvertToDto());
}
public void GetKundeByIdTest()
{
KundeDto kunde = new KundeDto {
Id = 3, Nachname = "Pfahl", Vorname = "Martha", Geburtsdatum = new DateTime(1990, 07, 03)
};
KundeDto resultKunde = Target.GetCustomer(kunde.Id);
Assert.True(resultKunde.CompareTo(kunde));
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto kunde = Target.GetCustomer(3);
kunde.Vorname = "Bob";
Target.UpdateCustomer(kunde);
kunde.Nachname = "Bobbington";
Assert.Throws <OptimisticConcurrencyException <Kunde> >(() => Target.UpdateCustomer(kunde));
}
public void InsertKundeTest()
{
kundeDto.Id = 5;
KundeDto newKundeDto = Target.InsertKunde(kundeDto);
Assert.AreEqual(5, newKundeDto.Id);
Assert.IsNotNull(newKundeDto.RowVersion);
Assert.IsNotNull(Target.GetKundeById(5));
}
public void UpdateKundeTest()
{
KundeDto kunde = Target.GetKundeById(1);
kunde.Vorname = "TestVorname";
Target.UpdateKunde(kunde);
kunde = Target.GetKundeById(1);
Assert.Equal("TestVorname", kunde.Vorname);
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto testingCustomer1 = Service.getCustomerByPrimaryKey(1);
KundeDto testingCustomer2 = Service.getCustomerByPrimaryKey(1);
testingCustomer1.Nachname = "Clinton";
testingCustomer2.Nachname = "Gollum";
Service.updateCustomer(testingCustomer1);
Service.updateCustomer(testingCustomer2);
}
public void UpdateKundeTest()
{
KundeDto kunde = Target.Kunden[0];
kunde.Vorname = "Ueli";
Target.UpdateKunde(kunde);
Assert.AreEqual("Ueli", Target.Kunden[0].Vorname);
}
public KundeHinzufügenViewModel GenerateModifyKundeHinzufügenViewModel(KundeDto kunde)
{
return(new KundeHinzufügenViewModel
{
IsNew = false,
Vorname = kunde.Vorname,
Nachname = kunde.Nachname,
Geburtsdatum = kunde.Geburtsdatum
});
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto testKunde1 = service.getCustomerById(1);
KundeDto testKunde2 = service.getCustomerById(1);
testKunde1.Nachname = "Johnson";
testKunde2.Nachname = "Graham";
service.modifyCustomer(testKunde1);
service.modifyCustomer(testKunde2);
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto kunde1 = Target.GetKundeById(1);
KundeDto kunde2 = Target.GetKundeById(1);
kunde1.Nachname = "Mann";
kunde2.Nachname = "Gruber";
Target.UpdateKunde(kunde1);
Target.UpdateKunde(kunde2);
}
public void DeleteKundeTest()
{
KundeDto dbKunde = Target.GetKundeById(1);
Target.DeleteKunde(dbKunde);
KundeDto deletedKunde = Target.GetKundeById(dbKunde.Id);
Assert.IsNull(deletedKunde);
}
public KundeDto UpdateKunde(KundeDto kunde)
{
try {
bc.UpdateKunde(kunde.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Kunde> e) {
throw new FaultException <KundeDto>(e.MergedEntity.ConvertToDto(), e.Message);
}
return(kunde);
}
protected override void ExecuteReloadCommand()
{
this.kundeDto = AutoReservationService.GetKunde(this.Id);
OnPropertyChanged(nameof(Nachname));
OnPropertyChanged(nameof(Vorname));
OnPropertyChanged(nameof(Geburtsdatum));
OnPropertyChanged(nameof(RowVersion));
OnPropertyChanged(nameof(CanSafe));
OnPropertyChanged(nameof(CanReload));
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto tempKundeDto = Target.GetKundeById(1);
KundeDto tempKundeDtoTwo = Target.GetKundeById(1);
tempKundeDto.Nachname = "Muster";
Target.UpdateKunde(tempKundeDto);
tempKundeDtoTwo.Nachname = "Meier";
Target.UpdateKunde(tempKundeDtoTwo);
Assert.Fail();
}
private void AddCustomer(KundeDto customer)
{
try
{
customer.Id = target.AddCustomer(customer);
}
catch (Exception e)
{
throw new RepositoryException("Kunde konnte nicht hinzugefügt werden.", e);
}
}
private void DeleteCustomer(KundeDto customer)
{
try
{
target.DeleteCustomer(customer);
}
catch (Exception e)
{
throw new RepositoryException("Kunde konnte nicht gelöscht werden.", e);
}
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto kunde1 = Target.GetKunde(1);
KundeDto kunde2 = Target.GetKunde(1);
kunde1.Vorname = "Test1";
kunde2.Vorname = "Test2";
Target.UpdateKunde(kunde1);
Assert.Throws <FaultException <OptimisticConcurrencyFault <KundeDto> > >(() => Target.UpdateKunde(kunde2));
}
public void Add()
{
Index = -1;
CurrentKundeDto = new KundeDto();
DetailsVisibility = true;
SaveCommand.RaiseCanExecuteChanged();
OnPropertyChanged(nameof(Index));
OnPropertyChanged(nameof(CurrentKundeDto));
OnPropertyChanged(nameof(DetailsVisibility));
}
public void InsertKundeTest()
{
var count = Target.GetAllKundenDtos().Count;
var kunde = new KundeDto();
kunde.Geburtsdatum = new DateTime(1988, 12, 30);
kunde.Vorname = "Marco";
kunde.Nachname = "Polo";
Target.InsertKunde(kunde);
Assert.Equal(count + 1, Target.GetAllKundenDtos().Count);
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto kunde1 = Target.FindKundeById(1);
KundeDto kunde2 = Target.FindKundeById(1);
kunde1.Nachname = "Hengscht";
kunde2.Nachname = "Sauber";
Target.UpdateKunde(kunde2);
Target.UpdateKunde(kunde1);
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto updateKunde1 = Target.GetKundeById(1);
updateKunde1.Nachname = "Hugetobler";
KundeDto updateKunde2 = Target.GetKundeById(1);
updateKunde2.Nachname = "Ibisevic";
Target.UpdateKunde(updateKunde1);
Target.UpdateKunde(updateKunde2);
}
public void InsertReservationTest()
{
KundeDto kunde = Target.GetKundeById(1);
AutoDto auto = Target.GetAutoById(1);
ReservationDto reservationdto = new ReservationDto {
ReservationsNr = 4, Von = new DateTime(2017, 12, 01), Bis = new DateTime(2018, 01, 01), Auto = auto, Kunde = kunde
};
Target.InsertReservation(reservationdto);
Assert.AreEqual(Target.GetReservationByReservationsNr(4).Auto.Marke, "Fiat Punto");
}
public void InsertKundeTest()
{
KundeDto kunde = new KundeDto
{
Geburtsdatum = new DateTime(1997, 05, 21),
Nachname = "Muster",
Vorname = "Hans"
};
Target.InsertKunde(kunde);
}
public void UpdateKundeWithOptimisticConcurrencyTest()
{
KundeDto k1 = Target.GetKunde(1);
KundeDto k2 = Target.GetKunde(1);
k1.Nachname = "Caesar";
k2.Nachname = "Schnitel";
Target.UpdateKunde(k1);
Target.UpdateKunde(k2);
}
public KundeDto UpdateKunde(KundeDto kunde)
{
try
{
WriteActualMethod();
return(DtoConverter.ConvertToDto(ServiceKunde.UpdateKunde(DtoConverter.ConvertToEntity(kunde))));
}
catch (OptimisticConcurrencyException <Kunde> ex)
{
throw new FaultException <KundeDto>(ex.MergedEntity.ConvertToDto(), ex.Message);
}
}
