private static (IRill Rill, InterceptingStore, IRillTransaction Transaction) NewScenario()
{
var rill = RillFactory.Synchronous(RillReference.New("rill-tran-tests"));
var tran = RillTransaction.Begin(rill);
return(rill, new InterceptingStore(), tran);
}
public void Can_be_reconstructed()
{
var org = RillReference.New(Fake.Strings.Random());
var reconstructed = RillReference.From(org.Name, org.Id);
org.Should().Be(reconstructed);
}
public void Can_not_be_reconstructed_if_parts_are_missing()
{
Action missingName = () => RillReference.From(string.Empty, string.Empty);
Action missingId = () => RillReference.From(Fake.Strings.Random(), string.Empty);
missingName.Should().Throw <ArgumentException>().And.ParamName.Should().Be("name");
missingId.Should().Throw <ArgumentException>().And.ParamName.Should().Be("id");
}
public void Can_be_constructed()
{
var name = Fake.Strings.Random();
var constructed = RillReference.New(name);
constructed.Name.Should().Be(name);
constructed.Id.Should().NotBeEmpty();
}
public RillStoreConcurrencyException(
RillReference reference,
Sequence currentSequence,
Sequence expectedSequence,
string message) : base(message)
{
Reference = reference;
CurrentSequence = currentSequence;
ExpectedSequence = expectedSequence;
}
public void New_uses_sensible_defaults()
{
var reference = RillReference.New("test");
var header = RillDetails.New(reference);
header.Reference.Should().Be(reference);
header.Sequence.Should().Be(Sequence.None);
header.LastChangedAt.Should().Be(header.CreatedAt);
((DateTime)header.CreatedAt).Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromMilliseconds(500));
((DateTime)header.LastChangedAt).Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromMilliseconds(500));
}
public void Can_not_be_constructed_When_last_changed_takes_presence_before_created()
{
var ts = DateTime.UtcNow;
Action failing = () => RillDetails.From(
RillReference.New("test"),
Sequence.First,
Timestamp.From(ts),
Timestamp.From(ts.AddMilliseconds(-1)));
failing.Should()
.ThrowExactly <ArgumentException>()
.WithMessage("Last changed can not take presence before Created timestamp.");
}
private static async Task ShipOrderAsync(IRillStore orderStore, RillReference reference)
{
using var rill = RillFactory.Synchronous(reference);
var view = new OrderView(rill);
foreach (var c in orderStore.ReadCommits(reference))
{
rill.Emit(c);
}
using var transaction = RillTransaction.Begin(rill);
rill.Emit(new OrderShipped(view.OrderNumber !, DateTime.UtcNow));
view.Dump("After OrderShipped");
var commit = await transaction.CommitAsync(orderStore);
Console.WriteLine($"Committed {commit}");
}
public static async Task Main()
{
var config = CreateConfiguration();
var orderStore = await CreateEfRillStoreAsync(config);
var rillReference = RillReference.New("order");
await PlaceAndApproveOrderAsync(orderStore, rillReference);
await ShipOrderAsync(orderStore, rillReference);
Console.WriteLine("**************************");
Console.WriteLine("All commits:");
Console.WriteLine("**************************");
await foreach (var commit in orderStore.ReadCommitsAsync(rillReference))
{
Console.WriteLine(commit);
}
Console.WriteLine("**************************");
await orderStore.DeleteAsync(rillReference);
}
private static async Task PlaceAndApproveOrderAsync(IRillStore orderStore, RillReference reference)
{
using var rill = RillFactory.Synchronous(reference);
var view = new OrderView(rill);
using var transaction = RillTransaction.Begin(rill);
rill.Emit(new OrderPlaced(
"order#1",
"customer#1",
100M,
DateTime.UtcNow));
view.Dump("After OrderPlaced");
rill.Emit(new OrderApproved(view.OrderNumber !, DateTime.UtcNow));
view.Dump("After OrderApproved");
var commit = await transaction.CommitAsync(orderStore);
Console.WriteLine($"Committed {commit}");
}
private static IRill NewSut()
=> RillFactory.Synchronous(RillReference.New("sync-rill-tests"));
private static IQueryable <RillCommitEntity> Matching(this IQueryable <RillCommitEntity> commits, RillReference reference) => commits.Where(c => c.RillId == reference.Id);
internal static IQueryable <RillCommitEntity> Matching(this IQueryable <RillCommitEntity> commits, RillReference reference, SequenceRange range)
=> range == SequenceRange.Any
? commits.Matching(reference)
: commits.Matching(reference).Matching(range);
public RillStoreIsCorruptException(
RillReference reference,
string message) : base(message)
{
Reference = reference;
}
internal RillDetails ToDetails() =>
RillDetails.From(
RillReference.From(Name, Id),
Rill.Sequence.From(Sequence),
Timestamp.From(CreatedAt.UtcDateTime),
Timestamp.From(LastChangedAt.UtcDateTime));
internal static RillEntity New(RillReference reference, SequenceRange sequenceRange, Timestamp createdAt) => From(reference, sequenceRange, createdAt, createdAt);
internal static RillEntity From(RillReference reference, SequenceRange sequenceRange, Timestamp createdAt, Timestamp lastChangedAt) => new(reference.Name, reference.Id, (long)sequenceRange.Upper, createdAt, lastChangedAt);
public void Can_not_be_constructed_if_parts_are_missing()
{
Action missingName = () => RillReference.New(string.Empty);
missingName.Should().Throw <ArgumentException>().And.ParamName.Should().Be("name");
}
