public async Task TestUpdate()
{
// Arrange
var person = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
string newVorname;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAct = await personen.GetById(person.BaPersonID);
newVorname = personAct.Vorname + "-test";
personAct.Vorname = newVorname;
//await personen.InsertOrUpdateEntity(personAct);
await context.SaveChangesAsync();
}
// Assert
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAssert = await personen.GetById(person.BaPersonID);
personAssert.Vorname.ShouldBe(newVorname);
}
}
public async Task TestUpdateShouldAffectRowversion()
{
// Arrange
var testPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
byte[] rowversionBefore;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var person = await personen.GetById(testPerson.BaPersonID);
rowversionBefore = testPerson.BaPersonTs;
person.Vorname += "test";
await personen.InsertOrUpdateEntity(person);
await context.SaveChangesAsync();
}
// Assert
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAssert = await personen.GetById(testPerson.BaPersonID);
personAssert.ShouldNotBeNull();
var rowversionAfter = personAssert.BaPersonTs;
rowversionAfter.ShouldNotBe(rowversionBefore);
}
}
public async Task Authenticate_HasClaims()
{
var testServerHandler = IntegrationTestEnvironment.TestIdentityServer.CreateHandler();
var discoveryClient = new DiscoveryClient(TestServerFixture.Authority, testServerHandler);
discoveryClient.Policy.ValidateIssuerName = false;
var disco = await discoveryClient.GetAsync();
disco.Error.ShouldBeNull();
var userTestData = IntegrationTestEnvironment.TestData <XUserTestData>();
var admin = userTestData.Administrator;
var tokenClient = new TokenClient(disco.TokenEndpoint, "webclient.ro", "EA59A39A-B03D-4985-A4FA-9297663A1858", testServerHandler);
var tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync(admin.LogonName, XUserTestData.AdminPassword, "api");
tokenResponse.Error.ShouldBeNull();
var token = new JwtSecurityTokenHandler().ReadToken(tokenResponse.AccessToken) as JwtSecurityToken;
token.ShouldNotBeNull();
token.Claims.ShouldContain(clm => clm.Type == Kiss4WebClaims.LogonName);
token.Claims.ShouldContain(clm => clm.Type == Kiss4WebClaims.ShortName);
token.Claims.First(clm => clm.Type == Kiss4WebClaims.LogonName).Value.ShouldBe(admin.LogonName);
token.Claims.First(clm => clm.Type == Kiss4WebClaims.ShortName).Value.ShouldBe(admin.ShortName);
}
public async Task TestUpdateUnchangedEntityInDifferentContextTimestampShouldBeUnchanged()
{
// Arrange
var testPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
var testPersonId = testPerson.Id;
byte[] timestampBefore;
byte[] timestampAfter;
byte[] timestampNewRead;
// Act
// Testperson laden
BaPerson person;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
person = await personen.GetById(testPersonId);
timestampBefore = person.BaPersonTs;
}
// make a change and then reverse it
var originalName = person.Name;
person.Name = originalName + " test";
person.Name = originalName;
// save
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
await personen.InsertOrUpdateEntity(person);
await context.SaveChangesAsync();
timestampAfter = person.BaPersonTs;
}
// Assert
BaPerson personAssert;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
personAssert = await personen.GetById(testPersonId);
timestampNewRead = personAssert.BaPersonTs;
}
personAssert.Name.ShouldBe(testPerson.Name);
timestampBefore.ShouldBe(timestampAfter, "Timestamp should be unchanged since the entity was unchanged");
timestampBefore.ShouldBe(timestampNewRead, "Timestamp should be unchanged also on the database");
}
public async Task TestGet()
{
var expectedPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var person = await personen.GetById(expectedPerson.Id);
// Assert
person.ShouldNotBeNull("Person not found");
person.BaPersonID.ShouldBe(expectedPerson.Id);
person.Name.ShouldBe(expectedPerson.Name);
person.Vorname.ShouldBe(expectedPerson.Vorname);
}
}
public async Task Authenticate_Failure()
{
var testServerHandler = IntegrationTestEnvironment.TestIdentityServer.CreateHandler();
var discoveryClient = new DiscoveryClient(TestServerFixture.Authority, testServerHandler);
discoveryClient.Policy.ValidateIssuerName = false;
var disco = await discoveryClient.GetAsync();
disco.Error.ShouldBeNull();
var userTestData = IntegrationTestEnvironment.TestData <XUserTestData>();
var admin = userTestData.Administrator;
var tokenClient = new TokenClient(disco.TokenEndpoint, "webclient.ro", "EA59A39A-B03D-4985-A4FA-9297663A1858", testServerHandler);
var tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync(admin.LogonName, XUserTestData.AdminPassword + "Wrong", "api");
tokenResponse.IsError.ShouldBeTrue();
}
public async Task TestGetInUnchangedState()
{
var expectedPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <Kiss4DbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var person = await personen.GetById(expectedPerson.Id);
// Assert
context.ChangeTracker.DetectChanges();
var entry = context.ChangeTracker.Entries <BaPerson>().FirstOrDefault(prs => prs.Entity.BaPersonID == person.Id);
entry.ShouldNotBeNull();
entry.State.ShouldBe(EntityState.Unchanged);
}
}
public async Task TestUpdateDetectConcurrencyProblem()
{
// Arrange
var person = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
// first User gets an entity
BaPerson personGet;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
personGet = await personen.GetById(person.BaPersonID);
personGet.Bemerkung += "bla";
}
// simulate second (quicker) User who changes the same entity
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personQuick = await personen.GetById(person.BaPersonID);
personQuick.Bemerkung += "blabla";
//await personen.InsertOrUpdateEntity(person);
await context.SaveChangesAsync();
}
// nun speichert der langsamere User und sollte eine Concurrency-Exception erhalten
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
await personen.InsertOrUpdateEntity(personGet);
var ex = await Should.ThrowAsync <DbUpdateConcurrencyException>(() => context.SaveChangesAsync(), "Concurrency problem was not detected");
}
}
public async Task TestInsertWithReference()
{
var testPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Arrange
const string strasse = "Teststrasse";
var baPersonId = testPerson.BaPersonID;
var adresse = new BaAdresse
{
BaPerson = testPerson,
BaPersonId = testPerson.BaPersonID,
Strasse = strasse
};
// Act
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var adressen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaAdresse> >();
await adressen.InsertOrUpdateEntity(adresse);
await context.SaveChangesAsync();
}
var baPersonIdInserted = adresse.BaPersonId;
// Assert
adresse.BaAdresseId.ShouldNotBe(0);
baPersonIdInserted.ShouldBe(baPersonId, "Referenzierte Person darf nicht noch einmal eingefügt werden");
BaAdresse adresseAssert;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var adressen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaAdresse> >();
adresseAssert = await adressen.GetById(adresse.BaAdresseId);
}
adresseAssert.Strasse.ShouldBe(strasse);
adresseAssert.BaPersonId.ShouldBe(baPersonId);
}
public async Task Test_DontUpdateUnchangedReferencedEntity()
{
var testUser = IntegrationTestEnvironment.TestData <XUserTestData>().Administrator;
var testAdresse = new BaAdresse
{
UserId = testUser.UserID,
Bemerkung = "testadresse"
};
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <Kiss4DbContext>();
var adressen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaAdresse> >();
await adressen.InsertOrUpdateEntity(testAdresse);
await context.SaveChangesAsync();
}
// Arrange
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <Kiss4DbContext>();
var adressen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaAdresse> >();
var adresse = await adressen.Where(adr => adr.Id == testAdresse.BaAdresseId)
.Include(adr => adr.User)
.FirstOrDefaultAsync();
// Act
adresse.Bemerkung += "blabla";
await adressen.InsertOrUpdateEntity(adresse);
// wird XUser updated? falls ja, gibt es eine exception, weil keine HistoryVersion erstellt wurde
await context.SaveChangesAsync();
// Assert
// nop, keine exception heisst ok
}
}
public async Task TestRemove()
{
// Arrange
var person = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
personen.Remove(person);
await context.SaveChangesAsync();
}
// Assert
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAssert = await personen.GetById(person.BaPersonID);
personAssert.ShouldBeNull();
}
}
public async Task Test_UpdateAfterDeleteByOtherUser_ExceptionShouldBeThrown()
{
// Arrange
var testPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
// Act
BaPerson person;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
person = await personen.GetById(testPerson.BaPersonID);
}
var originalName = person.Name;
person.Name = originalName + " test";
person.Name = originalName;
// other user deletes entity
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <Kiss4DbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
personen.Remove(prs => prs.BaPersonID == testPerson.BaPersonID);
person = await personen.GetById(testPerson.BaPersonID);
await context.SaveChangesAsync();
}
// try to save
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
await Should.ThrowAsync <DbUpdateException>(() => personen.InsertOrUpdateEntity(person));
}
}
public async Task TestUpdate_CreatedShouldBeUnchanged()
{
// Arrange
var person = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;
var now = new DateTime(2020, 1, 1);
IntegrationTestEnvironment.DateTime.SetLocalTime(now);
var createdBefore = person.Created;
// Act
string newVorname;
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var context = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAct = await personen.GetById(person.BaPersonID);
newVorname = personAct.Vorname + "-test";
personAct.Vorname = newVorname;
//await personen.InsertOrUpdateEntity(personAct);
await context.SaveChangesAsync();
}
// Assert
using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
{
var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
var personAssert = await personen.GetById(person.BaPersonID);
personAssert.Vorname.ShouldBe(newVorname);
personAssert.Created.ShouldBeWithSqlDateTimePrecision(createdBefore);
}
}
