public void UpdateReservationTestWithOptimisticConcurrency()
{
TestEnvironmentHelper.InitializeTestData();
AutoReservationBusinessComponent target = new AutoReservationBusinessComponent();
// Client 1
ReservationDto originalReservation1 = target.Reservationen[0];
ReservationDto modifiedReservation1 = (ReservationDto)originalReservation1.Clone();
modifiedReservation1.Bis = DateTime.Today.AddSeconds(10);
// Client 2
ReservationDto originalReservation2 = target.Reservationen[0];
ReservationDto modifiedReservation2 = (ReservationDto)originalReservation2.Clone();
modifiedReservation2.Bis = DateTime.Today.AddSeconds(20);
//Client 1 Update
target.UpdateReservation(modifiedReservation1, originalReservation1);
//Client 2 Update
try
{
target.UpdateReservation(modifiedReservation2, originalReservation2);
Assert.Fail();
}
catch (OptimisticConcurrencyException <ReservationDto> ) { }
catch { Assert.Fail("Unexpected Exception"); }
}
public void UpdateReservationTest()
{
TestEnvironmentHelper.InitializeTestData();
AutoReservationBusinessComponent target = new AutoReservationBusinessComponent();
ReservationDto reservation = new ReservationDto
{
Auto = target.Autos[0],
Kunde = target.Kunden[0],
Von = DateTime.Today,
Bis = DateTime.Today.AddDays(10)
};
int reservationNr = target.InsertReservation(reservation);
Assert.AreNotEqual(0, reservationNr);
ReservationDto org = target.GetReservationByNr(reservationNr);
ReservationDto mod = target.GetReservationByNr(reservationNr);
mod.Von = DateTime.Today.AddYears(1);
mod.Bis = DateTime.Today.AddDays(10).AddYears(1);
target.UpdateReservation(mod, org);
ReservationDto result = target.GetReservationByNr(reservationNr);
Assert.AreEqual(mod.ReservationNr, result.ReservationNr);
Assert.AreEqual(mod.Auto.Id, result.Auto.Id);
Assert.AreEqual(mod.Kunde.Id, result.Kunde.Id);
Assert.AreEqual(mod.Von, result.Von);
Assert.AreEqual(mod.Bis, result.Bis);
}
public ReservationDto UpdateReservation(ReservationDto reservation)
{
try {
bc.UpdateReservation(reservation.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Reservation> e) {
throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto(), e.Message);
}
return(reservation);
}
public void UpdateReservation(Common.DataTransferObjects.ReservationDto originalDto, Common.DataTransferObjects.ReservationDto modifiedDto)
{
try
{
businessComponent.UpdateReservation(DtoConverter.ConvertToEntity(originalDto), DtoConverter.ConvertToEntity(modifiedDto));
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
throw new FaultException <Common.DataTransferObjects.ReservationDto>(originalDto, e.Message);
}
}
public ReservationDto UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
try
{
return(service.UpdateReservation(reservation.ConvertToEntity()).ConvertToDto());
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto());
}
}
public ReservationDto UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(_businessLayer.UpdateReservation(DtoConverter.ConvertToEntity(reservation))));
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto(), "Reservation update failed");
}
}
public void UpdateReservation(ReservationDto modified, ReservationDto original)
{
WriteActualMethod();
try
{
_businessComponent.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto());
}
}
public void UpdateReservationTest()
{
Reservation original = Target.GetReservationById(1);
Reservation modified = Target.GetReservationById(1);
modified.Von = new DateTime(2020, 1, 20);
modified.Bis = new DateTime(2020, 1, 30);
target.UpdateReservation(original, modified);
Reservation newOriginal = Target.GetReservationById(1);
Assert.AreEqual(newOriginal.Von, new DateTime(2020, 1, 20));
Assert.AreEqual(newOriginal.Bis, new DateTime(2020, 1, 30));
}
public void UpdateReservationTest()
{
TestEnvironmentHelper.InitializeTestData();
var component = new AutoReservationBusinessComponent();
var oldReservation = component.GetReservationen()[0];
var newReservation = component.GetReservationen()[0];
Assert.AreNotSame(newReservation, oldReservation);
newReservation.Von = newReservation.Von.AddDays(3);
newReservation.Bis = newReservation.Bis.AddDays(3).AddYears(1);
Assert.AreNotEqual(newReservation, component.GetReservationen()[0]);
component.UpdateReservation(newReservation, oldReservation);
Assert.AreEqual(newReservation, component.GetReservationen()[0]);
}
public ReservationDto UpdateReservation(ReservationDto reservationDto)
{
try
{
Reservation reservation = reservationDto.ConvertToEntity();
return(autoReservationBusinessComponent.UpdateReservation(reservation).ConvertToDto());
} catch (LocalOptimisticConcurrencyException <Reservation> ex)
{
OptimisticConcurrencyFaultContract ocfc = new OptimisticConcurrencyFaultContract
{
Operation = "UpdateReservation",
Message = ex.Message
};
throw new FaultException <OptimisticConcurrencyFaultContract>(ocfc);
}
}
public void UpdateReservation(ReservationDto modified, ReservationDto original)
{
try
{
WriteActualMethod();
component.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Reservation> ex)
{
var e = new OptimisticConcurrencyException <ReservationDto> {
Entity = ex.Entity.ConvertToDto()
};
throw new FaultException <OptimisticConcurrencyException <ReservationDto> >(e);
}
}
public void UpdateReservation(ReservationDto original, ReservationDto modified)
{
WriteActualMethod();
try
{
_businessComponent.UpdateReservation(original.ConvertToEntity(), modified.ConvertToEntity());
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
var fault = new LocalOptimisticConcurrencyFault()
{
Message = e.Message
};
throw new FaultException <LocalOptimisticConcurrencyFault>(fault);
}
}
public void UpdateReservationTestWithOptimisticConcurrency()
{
TestEnvironmentHelper.InitializeTestData();
AutoReservationBusinessComponent target = new AutoReservationBusinessComponent();
// Client 1
ReservationDto originalReservation1 = target.Reservationen[0];
ReservationDto modifiedReservation1 = (ReservationDto)originalReservation1.Clone();
modifiedReservation1.Bis = DateTime.Today.AddSeconds(10);
// Client 2
ReservationDto originalReservation2 = target.Reservationen[0];
ReservationDto modifiedReservation2 = (ReservationDto)originalReservation2.Clone();
modifiedReservation2.Bis = DateTime.Today.AddSeconds(20);
//Client 1 Update
target.UpdateReservation(modifiedReservation1, originalReservation1);
//Client 2 Update
try
{
target.UpdateReservation(modifiedReservation2, originalReservation2);
Assert.Fail();
}
catch (OptimisticConcurrencyException<ReservationDto>) { }
catch { Assert.Fail("Unexpected Exception"); }
}
public void UpdateReservationTest()
{
TestEnvironmentHelper.InitializeTestData();
AutoReservationBusinessComponent target = new AutoReservationBusinessComponent();
ReservationDto reservation = new ReservationDto
{
Auto = target.Autos[0],
Kunde = target.Kunden[0],
Von = DateTime.Today,
Bis = DateTime.Today.AddDays(10)
};
int reservationNr = target.InsertReservation(reservation);
Assert.AreNotEqual(0, reservationNr);
ReservationDto org = target.GetReservationByNr(reservationNr);
ReservationDto mod = target.GetReservationByNr(reservationNr);
mod.Von = DateTime.Today.AddYears(1);
mod.Bis = DateTime.Today.AddDays(10).AddYears(1);
target.UpdateReservation(mod, org);
ReservationDto result = target.GetReservationByNr(reservationNr);
Assert.AreEqual(mod.ReservationNr, result.ReservationNr);
Assert.AreEqual(mod.Auto.Id, result.Auto.Id);
Assert.AreEqual(mod.Kunde.Id, result.Kunde.Id);
Assert.AreEqual(mod.Von, result.Von);
Assert.AreEqual(mod.Bis, result.Bis);
}
public ReservationDto UpdateReservation(ReservationDto reservationDto)
{
WriteActualMethod();
return(handlingOptimisticConcurrencyException <Reservation, ReservationDto>("UpdateReservation",
() => component.UpdateReservation(reservationDto.ConvertToEntity()).ConvertToDto()));
}
public void UpdateReservation(ReservationDto original, ReservationDto modified)
{
WriteActualMethod();
component.UpdateReservation(original.ConvertToEntity(), modified.ConvertToEntity());
}
public void UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
businessComponent.UpdateReservation(reservation.ConvertToEntity());
}
