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);
        }
Esempio n. 2
0
        public void Can_be_reconstructed()
        {
            var org = RillReference.New(Fake.Strings.Random());

            var reconstructed = RillReference.From(org.Name, org.Id);

            org.Should().Be(reconstructed);
        }
Esempio n. 3
0
        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");
        }
Esempio n. 4
0
        public void Can_be_constructed()
        {
            var name = Fake.Strings.Random();

            var constructed = RillReference.New(name);

            constructed.Name.Should().Be(name);
            constructed.Id.Should().NotBeEmpty();
        }
Esempio n. 5
0
 public RillStoreConcurrencyException(
     RillReference reference,
     Sequence currentSequence,
     Sequence expectedSequence,
     string message) : base(message)
 {
     Reference        = reference;
     CurrentSequence  = currentSequence;
     ExpectedSequence = expectedSequence;
 }
Esempio n. 6
0
        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));
        }
Esempio n. 7
0
        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.");
        }
Esempio n. 8
0
        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}");
        }
Esempio n. 9
0
        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);
        }
Esempio n. 10
0
        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}");
        }
Esempio n. 11
0
 private static IRill NewSut()
 => RillFactory.Synchronous(RillReference.New("sync-rill-tests"));
Esempio n. 12
0
 private static IQueryable <RillCommitEntity> Matching(this IQueryable <RillCommitEntity> commits, RillReference reference)
 => commits.Where(c => c.RillId == reference.Id);
Esempio n. 13
0
 internal static IQueryable <RillCommitEntity> Matching(this IQueryable <RillCommitEntity> commits, RillReference reference, SequenceRange range)
 => range == SequenceRange.Any
         ? commits.Matching(reference)
         : commits.Matching(reference).Matching(range);
Esempio n. 14
0
 public RillStoreIsCorruptException(
     RillReference reference,
     string message) : base(message)
 {
     Reference = reference;
 }
Esempio n. 15
0
 internal RillDetails ToDetails() =>
 RillDetails.From(
     RillReference.From(Name, Id),
     Rill.Sequence.From(Sequence),
     Timestamp.From(CreatedAt.UtcDateTime),
     Timestamp.From(LastChangedAt.UtcDateTime));
Esempio n. 16
0
 internal static RillEntity New(RillReference reference, SequenceRange sequenceRange, Timestamp createdAt)
 => From(reference, sequenceRange, createdAt, createdAt);
Esempio n. 17
0
 internal static RillEntity From(RillReference reference, SequenceRange sequenceRange, Timestamp createdAt, Timestamp lastChangedAt)
 => new(reference.Name, reference.Id, (long)sequenceRange.Upper, createdAt, lastChangedAt);
Esempio n. 18
0
        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");
        }