public void UsesOptimisticLockingAndDetectsRaceConditionsWhenUpdatingFindingById()
{
var indexBySomeString = new[] { "Id" };
var id = Guid.NewGuid();
var simpleSagaData = new SimpleSagaData {
Id = id, SomeString = "hello world!"
};
Persister.Insert(simpleSagaData, indexBySomeString);
var sagaData1 = Persister.Find <SimpleSagaData>("Id", id);
sagaData1.SomeString = "I changed this on one worker";
EnterAFakeMessageContext();
var sagaData2 = Persister.Find <SimpleSagaData>("Id", id);
sagaData2.SomeString = "I changed this on another worker";
Persister.Update(sagaData2, indexBySomeString);
ReturnToOriginalMessageContext();
Assert.Throws <OptimisticLockingException>(() => Persister.Insert(sagaData1, indexBySomeString));
}
public void PersisterCanFindSagaById()
{
var savedSagaData = new MySagaData();
var savedSagaDataId = Guid.NewGuid();
savedSagaData.Id = savedSagaDataId;
Persister.Insert(savedSagaData, new string[0]);
var foundSagaData = Persister.Find <MySagaData>("Id", savedSagaDataId);
foundSagaData.Id.ShouldBe(savedSagaDataId);
}
public void CanFindSagaByPropertyValues()
{
Persister.Insert(SagaData(1, "some field 1"), new[] { "AnotherField" });
Persister.Insert(SagaData(2, "some field 2"), new[] { "AnotherField" });
Persister.Insert(SagaData(3, "some field 3"), new[] { "AnotherField" });
var dataViaNonexistentValue = Persister.Find <MySagaData>("AnotherField", "non-existent value");
var dataViaNonexistentField = Persister.Find <MySagaData>("SomeFieldThatDoesNotExist", "doesn't matter");
var mySagaData = Persister.Find <MySagaData>("AnotherField", "some field 2");
dataViaNonexistentField.ShouldBe(null);
dataViaNonexistentValue.ShouldBe(null);
mySagaData.SomeField.ShouldBe("2");
}
public void CanDeleteSaga()
{
var mySagaDataId = Guid.NewGuid();
var mySagaData = new SimpleSagaData
{
Id = mySagaDataId,
SomeString = "whoolala"
};
Persister.Insert(mySagaData, new[] { "SomeString" });
Persister.Delete(mySagaData);
var sagaData = Persister.Find <SimpleSagaData>("Id", mySagaDataId);
sagaData.ShouldBe(null);
}
void TestFindSagaByPropertyWithType <TProperty>(TProperty propertyValueToUse)
{
var propertyTypeToTest = typeof(TProperty);
var type = typeof(GenericSagaData <>);
var sagaDataType = type.MakeGenericType(typeof(TFactory), propertyTypeToTest);
var savedSagaData = (ISagaData)Activator.CreateInstance(sagaDataType);
var savedSagaDataId = Guid.NewGuid();
savedSagaData.Id = savedSagaDataId;
sagaDataType.GetProperty("Property").SetValue(savedSagaData, propertyValueToUse, new object[0]);
Persister.Insert(savedSagaData, new[] { "Property" });
var foundSagaData = Persister.Find <GenericSagaData <TProperty> >("Property", propertyValueToUse);
foundSagaData.Id.ShouldBe(savedSagaDataId);
}
public void SamePersisterCanSaveMultipleTypesOfSagaDatas()
{
var sagaId1 = Guid.NewGuid();
var sagaId2 = Guid.NewGuid();
Persister.Insert(new SimpleSagaData {
Id = sagaId1, SomeString = "Olé"
}, new[] { "Id" });
Persister.Insert(new MySagaData {
Id = sagaId2, AnotherField = "Yipiie"
}, new[] { "Id" });
var saga1 = Persister.Find <SimpleSagaData>("Id", sagaId1);
var saga2 = Persister.Find <MySagaData>("Id", sagaId2);
saga1.SomeString.ShouldBe("Olé");
saga2.AnotherField.ShouldBe("Yipiie");
}
public void ConcurrentDeleteAndUpdateThrowsOnDelete()
{
var indexBySomeString = new[] { "Id" };
var id = Guid.NewGuid();
var simpleSagaData = new SimpleSagaData {
Id = id
};
Persister.Insert(simpleSagaData, indexBySomeString);
var sagaData1 = Persister.Find <SimpleSagaData>("Id", id);
EnterAFakeMessageContext();
var sagaData2 = Persister.Find <SimpleSagaData>("Id", id);
sagaData2.SomeString = "Some new value";
Persister.Update(sagaData2, indexBySomeString);
ReturnToOriginalMessageContext();
Assert.Throws <OptimisticLockingException>(() => Persister.Delete(sagaData1));
}
public void PersisterCanFindSagaDataWithNestedElements()
{
const string stringValue = "I expect to find something with this string!";
var path = Reflect.Path <SagaDataWithNestedElement>(d => d.ThisOneIsNested.SomeString);
Persister.Insert(new SagaDataWithNestedElement
{
Id = Guid.NewGuid(),
Revision = 12,
ThisOneIsNested = new ThisOneIsNested
{
SomeString = stringValue
}
}, new[] { path });
var loadedSagaData = Persister.Find <SagaDataWithNestedElement>(path, stringValue);
loadedSagaData.ThisOneIsNested.ShouldNotBe(null);
loadedSagaData.ThisOneIsNested.SomeString.ShouldBe(stringValue);
}
public void CanInsertSagasOfMultipleTypes()
{
// arrange
var someString = "just happens to be the same in two otherwise unrelated sagas";
var someFieldPathOne = Reflect.Path <OneKindOfSaga>(s => s.SomeField);
var someFieldPathAnother = Reflect.Path <AnotherKindOfSaga>(s => s.SomeField);
// act
Persister.Insert(new OneKindOfSaga {
Id = Guid.NewGuid(), SomeField = someString
}, new[] { "Id", someFieldPathOne });
Persister.Insert(new AnotherKindOfSaga {
Id = Guid.NewGuid(), SomeField = someString
}, new[] { "Id", someFieldPathAnother });
var oneKindOfSagaLoaded = Persister.Find <OneKindOfSaga>(someFieldPathOne, someString);
var anotherKindOfSagaLoaded = Persister.Find <AnotherKindOfSaga>(someFieldPathAnother, someString);
// assert
oneKindOfSagaLoaded.ShouldBeTypeOf <OneKindOfSaga>();
anotherKindOfSagaLoaded.ShouldBeTypeOf <AnotherKindOfSaga>();
}
public void PersistsComplexSagaLikeExpected()
{
var sagaDataId = Guid.NewGuid();
var complexPieceOfSagaData =
new MySagaData
{
Id = sagaDataId,
SomeField = "hello",
AnotherField = "world!",
Embedded = new SomeEmbeddedThingie
{
ThisIsEmbedded = "this is embedded",
Thingies =
{
new SomeCollectedThing {
No = 1
},
new SomeCollectedThing {
No = 2
},
new SomeCollectedThing {
No = 3
},
new SomeCollectedThing {
No = 4
}
}
}
};
Persister.Insert(complexPieceOfSagaData, new[] { "SomeField" });
var sagaData = Persister.Find <MySagaData>("Id", sagaDataId);
sagaData.SomeField.ShouldBe("hello");
sagaData.AnotherField.ShouldBe("world!");
}
