public void AddedObject_ShouldGetCreationStateAssignedOnCommit() { var manager = new InMemoryObjectManager(); var transaction = manager.CreateTransaction(); // Internal version id should be 1 Assert.Equal(1, transaction.Version.InternalVersionId); var objToAdd = new TestObjectA(Guid.NewGuid(), "hej"); transaction.Add(objToAdd); // Creation version should not be assigned yet Assert.Null(objToAdd.CreationVersion); // Deletion version should be null Assert.Null(objToAdd.DeletionVersion); transaction.Commit(); // Creation version should now be assigned Assert.Equal(transaction.Version, objToAdd.CreationVersion); // Deletion version should still be null Assert.Null(objToAdd.DeletionVersion); }
public void AddDeleteAddSameObjectInstance_MustFail() { // Due to the way version is managed it's crutial that added objects are new instances var manager = new InMemoryObjectManager(); // FIRST TRANSACTION: Add two object var firstTransaction = manager.CreateTransaction(); var firstObj = new TestObjectA(Guid.NewGuid(), "first object"); firstTransaction.Add(firstObj); firstTransaction.Commit(); // SECOND TRANSACTION: Delete first object var secondTransaction = manager.CreateTransaction(); secondTransaction.Delete(firstObj.Id); secondTransaction.Commit(); // THIRD TRANSACTION: Add first object again - same instance - must fail var thirdTransaction = manager.CreateTransaction(); Assert.Throws <OperationCanceledException>(() => thirdTransaction.Add(firstObj)); }
public void AddDeleteTest_GetObjectsMustReturnCorrectResult() { var manager = new InMemoryObjectManager(); // FIRST TRANSACTION: Add two object var firstTransaction = manager.CreateTransaction(); var firstObj = new TestObjectA(Guid.NewGuid(), "first object"); firstTransaction.Add(firstObj); var secondObj = new TestObjectA(Guid.NewGuid(), "second object"); firstTransaction.Add(secondObj); firstTransaction.Commit(); // SECOND TRANSACTION: Delete first object var secondTransaction = manager.CreateTransaction(); secondTransaction.Delete(firstObj.Id); secondTransaction.Commit(); // THIRD TRANSACTION: Delete second object var thirdTransaction = manager.CreateTransaction(); thirdTransaction.Delete(secondObj.Id); thirdTransaction.Commit(); // FORTH TRANSACTION: Add second object again var forthTransaction = manager.CreateTransaction(); forthTransaction.Add(new TestObjectA(secondObj.Id, "second object version 2")); forthTransaction.Commit(); // In version 1 we should have 2 object Assert.Equal(2, manager.GetObjects(1).Count()); // In version 1 name of first object should be "first object" Assert.Contains(manager.GetObjects(1), o => o.Id == firstObj.Id && ((TestObjectA)o).Name == "first object"); // In version 1 name of second object should be "second object" Assert.Contains(manager.GetObjects(1), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); // In version 2 we should have only 1 object Assert.Single(manager.GetObjects(2)); // In version 2 we should have the second object named "second object" Assert.Contains(manager.GetObjects(2), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); // In version 3 we should have no objects Assert.Empty(manager.GetObjects(3)); // In version 4 we should have 1 object Assert.Single(manager.GetObjects(4)); // In version 4 we should have the second object named "second object version 2" Assert.Contains(manager.GetObjects(4), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object version 2"); }
public void AddingTheSameObjectTwiceInTheSameTransactions_MustFail() { var manager = new InMemoryObjectManager(); var firstTransaction = manager.CreateTransaction(); var objToAdd = new TestObjectA(Guid.NewGuid(), "hej"); firstTransaction.Add(objToAdd); Assert.Throws <OperationCanceledException>(() => firstTransaction.Add(objToAdd)); }
public void DeleteAfterRollback_MustFail() { var manager = new InMemoryObjectManager(); var firstTransaction = manager.CreateTransaction(); var objToAdd = new TestObjectA(Guid.NewGuid(), "hello"); firstTransaction.Add(objToAdd); firstTransaction.Rollback(); Assert.Throws <OperationCanceledException>(() => firstTransaction.Delete(objToAdd.Id)); }
public void UpdateAfterCommit_MustFail() { var manager = new InMemoryObjectManager(); var firstTransaction = manager.CreateTransaction(); var objToAdd = new TestObjectA(Guid.NewGuid(), "hello"); firstTransaction.Add(objToAdd); firstTransaction.Commit(); Assert.Throws <OperationCanceledException>(() => firstTransaction.Update(new TestObjectA(objToAdd.Id, "hello kitty"))); }
public void CreateTwoTransactionWithSameCustomId_MustFail() { var manager = new InMemoryObjectManager(); // First transaction var firstTransaction = manager.CreateTransaction("my custom version id 1"); var objToAdd = new TestObjectA(Guid.NewGuid(), "hej"); firstTransaction.Add(objToAdd); firstTransaction.Commit(); // Create second transaction with the same version id Assert.Throws <ArgumentException>(() => manager.CreateTransaction("my custom version id 1")); }
public void UpdateObjectWithSameInstance_MustFail() { var manager = new InMemoryObjectManager(); // FIRST TRANSACTION: Add two object var firstTransaction = manager.CreateTransaction(); var firstObj = new TestObjectA(Guid.NewGuid(), "first object"); firstTransaction.Add(firstObj); firstTransaction.Commit(); // SECOND TRANSACTION: Update object using same instance - must fail var secondTransaction = manager.CreateTransaction(); Assert.Throws <OperationCanceledException>(() => secondTransaction.Update(firstObj)); }
public void DiffBetweenTwoAdjacentVersions_CheckResult() { var manager = new InMemoryObjectManager(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // FIRST TRANSACTION var firstTransaction = manager.CreateTransaction(); var firstObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "first object")); var secondObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "second object")); var thirdObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "third object")); firstTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // SECOND TRANSACTION var secondTransaction = manager.CreateTransaction(); // Insert forth object var forthObj = secondTransaction.Add(new TestObjectA(Guid.NewGuid(), "forth object")); // Delete second object secondTransaction.Delete(secondObj.Id); // Update third object var thirdObjUpdated = new TestObjectA(thirdObj.Id, "third object updated"); secondTransaction.Update(thirdObjUpdated); secondTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Get the changes and assert correctness var changes = manager.GetChanges(1, 2); // We did 3 changes: add, delete and update. Assert.Equal(3, changes.Count()); Assert.Contains(changes, c => c is ObjectCreation && ((ObjectCreation)c).NewState == forthObj); Assert.Contains(changes, c => c is ObjectDeletion && c.Id == secondObj.Id); Assert.Contains(changes, c => c is ObjectModification && ((ObjectModification)c).NewState == thirdObjUpdated && ((ObjectModification)c).PreviousState == thirdObj); }
public void AddingObject_TestGetObject() { var manager = new InMemoryObjectManager(); var firstTransaction = manager.CreateTransaction("custom version id"); var objToAdd = new TestObjectA(Guid.NewGuid(), "hej"); firstTransaction.Add(objToAdd); firstTransaction.Commit(); // Asset that GetObject(guid id) workd Assert.Equal(objToAdd, manager.GetObject(objToAdd.Id)); // Asset that GetObject(guid id, long version id) works Assert.Equal(objToAdd, manager.GetObject(objToAdd.Id, 1)); // Asset that GetObject(custom, string version id ) works Assert.Equal(objToAdd, manager.GetObject(objToAdd.Id, "custom version id")); }
public void WorkAfterRollback_ShouldNotBeCommited() { var manager = new InMemoryObjectManager(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // FIRST TRANSACTION var firstTransaction = manager.CreateTransaction(); var firstObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "first object")); var secondObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "second object")); var thirdObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "third object")); firstTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // SECOND TRANSACTION var secondTransaction = manager.CreateTransaction(); // Insert forth object var forthObj = secondTransaction.Add(new TestObjectA(Guid.NewGuid(), "forth object")); // Delete second object secondTransaction.Delete(secondObj.Id); // Update third object var thirdObjUpdated = new TestObjectA(thirdObj.Id, "third object updated"); secondTransaction.Update(thirdObjUpdated); secondTransaction.Rollback(); // In version 1 we should have 3 object Assert.Equal(3, manager.GetObjects(1).Count()); // In version 1 name of first object should be "first object" Assert.Contains(manager.GetObjects(1), o => o.Id == firstObj.Id && ((TestObjectA)o).Name == "first object"); // In version 1 name of second object should be "second object" Assert.Contains(manager.GetObjects(1), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); // Version 2 should not exist, because we did a rollback of the second transaction Assert.Throws <ArgumentException>(() => manager.GetObjects(2)); }
public void UpdateObject_GetObjectsMustReturnCorrectResult() { var manager = new InMemoryObjectManager(); // FIRST TRANSACTION: Add two object var firstTransaction = manager.CreateTransaction(); var firstObj = new TestObjectA(Guid.NewGuid(), "first object"); firstTransaction.Add(firstObj); var secondObj = new TestObjectA(Guid.NewGuid(), "second object"); firstTransaction.Add(secondObj); firstTransaction.Commit(); // SECOND TRANSACTION: Update name of second object var secondTransaction = manager.CreateTransaction(); var updatedObj = new TestObjectA(secondObj.Id, "second object updated"); secondTransaction.Update(updatedObj); secondTransaction.Commit(); // In version 1 we should have 2 object Assert.Equal(2, manager.GetObjects(1).Count()); // In version 1 name of first object should be "first object" Assert.Contains(manager.GetObjects(1), o => o.Id == firstObj.Id && ((TestObjectA)o).Name == "first object"); // In version 1 name of second object should be "second object" Assert.Contains(manager.GetObjects(1), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); // In version 2 we should still have 2 object Assert.Equal(2, manager.GetObjects(2).Count()); // In version 2 name of first object should still be "first object" Assert.Contains(manager.GetObjects(2), o => o.Id == firstObj.Id && ((TestObjectA)o).Name == "first object"); // In version 2 name of second object should be changed to "second object updated" Assert.Contains(manager.GetObjects(2), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object updated"); }
public void DeleteObject_GetObjectsMustReturnCorrectResult() { var manager = new InMemoryObjectManager(); // FIRST TRANSACTION: Add two object var firstTransaction = manager.CreateTransaction(); var firstObj = new TestObjectA(Guid.NewGuid(), "first object"); firstTransaction.Add(firstObj); var secondObj = new TestObjectA(Guid.NewGuid(), "second object"); firstTransaction.Add(secondObj); firstTransaction.Commit(); // SECOND TRANSACTION: Delete first object var secondTransaction = manager.CreateTransaction(); secondTransaction.Delete(firstObj.Id); secondTransaction.Commit(); // Deletion version should not be null Assert.NotNull(firstObj.DeletionVersion); // In version 1 we should have 2 object Assert.Equal(2, manager.GetObjects(1).Count()); // In version 1 name of first object should be "first object" Assert.Contains(manager.GetObjects(1), o => o.Id == firstObj.Id && ((TestObjectA)o).Name == "first object"); // In version 1 name of second object should be "second object" Assert.Contains(manager.GetObjects(1), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); // In version 2 we should have only 1 object Assert.Single(manager.GetObjects(2)); // In version 2 we should have the second object named "second object" Assert.Contains(manager.GetObjects(2), o => o.Id == secondObj.Id && ((TestObjectA)o).Name == "second object"); }
public void CreateTransactionWithCustomId_TestGetObject() { var manager = new InMemoryObjectManager(); var myCustomId = "my custom version id 1"; var firstTransaction = manager.CreateTransaction(myCustomId); var objToAdd = new TestObjectA(Guid.NewGuid(), "hej"); firstTransaction.Add(objToAdd); firstTransaction.Commit(); // Asser that GetObjects work with custom ids var objects = manager.GetObjects(myCustomId); Assert.Single(objects); var obj = manager.GetObject(objToAdd.Id, myCustomId); Assert.Equal(objToAdd, obj); }
public void DiffBetweenManyVersions_CheckResult() { var manager = new InMemoryObjectManager(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // FIRST TRANSACTION var firstTransaction = manager.CreateTransaction(); var firstObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "first object")); var secondObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "second object")); var thirdObj = firstTransaction.Add(new TestObjectA(Guid.NewGuid(), "third object")); firstTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // SECOND TRANSACTION var secondTransaction = manager.CreateTransaction(); // Insert forth object var forthObj = secondTransaction.Add(new TestObjectA(Guid.NewGuid(), "forth object")); // Delete second object secondTransaction.Delete(secondObj.Id); // Update third object var thirdObjUpdatedFirstTime = new TestObjectA(thirdObj.Id, "third object updated first time"); secondTransaction.Update(thirdObjUpdatedFirstTime); secondTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // THIRD TRANSACTION var thirdTransaction = manager.CreateTransaction(); // Insert fifth object var fifthObj = thirdTransaction.Add(new TestObjectA(Guid.NewGuid(), "fifth object")); // Delete first object thirdTransaction.Delete(firstObj.Id); // Update third object again var thirdObjUpdatedSecondTime = new TestObjectA(thirdObj.Id, "third object updated second time"); thirdTransaction.Update(thirdObjUpdatedSecondTime); thirdTransaction.Commit(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Get the changes between version 1 and 2 and assert correctness var changes = manager.GetChanges(1, 2); // We did 3 changes: add, delete and update. Assert.Equal(3, changes.Count()); Assert.Contains(changes, c => c is ObjectCreation && ((ObjectCreation)c).NewState == forthObj); Assert.Contains(changes, c => c is ObjectDeletion && c.Id == secondObj.Id); Assert.Contains(changes, c => c is ObjectModification && ((ObjectModification)c).NewState == thirdObjUpdatedFirstTime && ((ObjectModification)c).PreviousState == thirdObj); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Get the changes between version 1 and 3 and assert correctness changes = manager.GetChanges(1, 3); // We did 5 changes: two add, two delete and one update. Assert.Equal(5, changes.Count()); Assert.Contains(changes, c => c is ObjectCreation && ((ObjectCreation)c).NewState == forthObj); Assert.Contains(changes, c => c is ObjectCreation && ((ObjectCreation)c).NewState == fifthObj); Assert.Contains(changes, c => c is ObjectDeletion && c.Id == firstObj.Id); Assert.Contains(changes, c => c is ObjectDeletion && c.Id == secondObj.Id); Assert.Contains(changes, c => c is ObjectModification && ((ObjectModification)c).NewState == thirdObjUpdatedSecondTime && ((ObjectModification)c).PreviousState == thirdObj); /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Get the changes between version 2 and 3 and assert correctness changes = manager.GetChanges(2, 3); // We did 3 changes: add, delete and update. Assert.Equal(3, changes.Count()); Assert.Contains(changes, c => c is ObjectCreation && ((ObjectCreation)c).NewState == fifthObj); Assert.Contains(changes, c => c is ObjectDeletion && c.Id == firstObj.Id); Assert.Contains(changes, c => c is ObjectModification && ((ObjectModification)c).NewState == thirdObjUpdatedSecondTime && ((ObjectModification)c).PreviousState == thirdObjUpdatedFirstTime); }
public void TestConcurrentReaderOneWriter() { var manager = new InMemoryObjectManager(); // Add initial object var transaction = manager.CreateTransaction(); var objToAdd = new TestObjectA(Guid.NewGuid(), "initial"); transaction.Add(objToAdd); transaction.Commit(); // Update name of object to inital 2 transaction = manager.CreateTransaction(); var objToUpdate = new TestObjectA(objToAdd.Id, "initial 2"); transaction.Update(objToUpdate); transaction.Commit(); // Thread that create a new transaction every 10 milisecond new Thread(() => { for (int i = 0; i < 100; i++) { var transaction = manager.CreateTransaction(); var objToUpdate = new TestObjectA(objToAdd.Id, "trans version " + transaction.Version.InternalVersionId); transaction.Update(objToUpdate); //Give some time to other threads to kick in Thread.Sleep(10); transaction.Commit(); Assert.Single(manager.GetObjects(transaction.Version.InternalVersionId)); } }).Start(); // Reading thread #1 new Thread(() => { for (int i = 0; i < 100; i++) { Assert.Single(manager.GetObjects(1)); Assert.Equal("initial", ((TestObjectA)manager.GetObjects(1).First()).Name); Thread.Sleep(10); } }).Start(); // Reading thread #2 new Thread(() => { for (int i = 0; i < 100; i++) { Assert.Single(manager.GetObjects(1)); Assert.Equal("initial", ((TestObjectA)manager.GetObjects(1).First()).Name); Thread.Sleep(10); } }).Start(); // Reading thread #3 new Thread(() => { for (int i = 0; i < 100; i++) { Assert.Single(manager.GetObjects(2)); Assert.Equal("initial 2", ((TestObjectA)manager.GetObjects(2).First()).Name); Thread.Sleep(10); } }).Start(); Thread.Sleep(1500); }