public void HasUncommittedEvents_DiffrentEventValues_DisplayedInTheMessage()
        {
            using (CultureInfoScope.NewInvariant())
            {
                var buffer = EventBuffer.Empty(Guid.NewGuid())
                             .Add(new object[]
                {
                    new EmptyEvent(),
                    new Complex {
                        Value = 17, Message = "Same", Date = new DateTime(2017, 06, 11)
                    },
                    new SimpleEvent(),
                });

                var x = Assert.Catch <AssertionFailed>(() =>
                                                       AggregateRootAssert.HasUncommittedEvents(buffer,
                                                                                                new EmptyEvent(),
                                                                                                new Complex {
                    Value = 23, Message = "Same", Date = new DateTime(1980, 06, 30)
                },
                                                                                                new SimpleEvent()
                                                                                                ));

                Assert.AreEqual(@"Assertion failed:
[0] EmptyEvent
[1] Expected: { Value: 23, Date: 06/30/1980 00:00:00 }
    Actual:   { Value: 17, Date: 06/11/2017 00:00:00 }
[2] SimpleEvent
", x.Message);
            }
        }
        public void HasUncommittedEvents_WithMissingEvents_DisplayedInTheMessage()
        {
            var buffer = EventBuffer.Empty(Guid.NewGuid())
                         .Add(new object[]
            {
                new EmptyEvent(),
                new OtherEvent {
                    Value = 3
                }
            });

            var x = Assert.Catch <AssertionFailed>(() =>
                                                   AggregateRootAssert.HasUncommittedEvents(buffer,
                                                                                            new EmptyEvent(),
                                                                                            new OtherEvent {
                Value = 3
            },
                                                                                            new SimpleEvent {
                Value = 5
            },
                                                                                            new OtherEvent {
                Value = 9
            }
                                                                                            ));

            Assert.AreEqual(@"Assertion failed:
[0] EmptyEvent
[1] OtherEvent
[2] Missing:  SimpleEvent
[3] Missing:  OtherEvent
", x.Message);
        }
        public void HasUncommittedEvents_EqualArrayValues_IsTrue()
        {
            var buffer = EventBuffer.Empty(Guid.NewGuid())
                         .Add(new ArrayEvent {
                Numbers = new[] { 17 }
            });

            AggregateRootAssert.HasUncommittedEvents(buffer,
                                                     new ArrayEvent {
                Numbers = new[] { 17 }
            });
        }
        public void HasUncommittedEvents_DifferentArrayValues_DisplayedInTheMessage()
        {
            var buffer = EventBuffer.Empty(Guid.NewGuid())
                         .Add(new ArrayEvent {
                Numbers = new[] { 17 }
            });

            var x = Assert.Catch <AssertionFailed>(() =>
                                                   AggregateRootAssert.HasUncommittedEvents(buffer,
                                                                                            new ArrayEvent {
                Numbers = new[] { 18 }
            }
                                                                                            ));

            Assert.AreEqual(@"Assertion failed:
[0] Expected: { Numbers: [ 18 ] }
    Actual:   { Numbers: [ 17 ] }
", x.Message);
        }
        public void HasUncommittedEvents_DiffrentEventTypes_DisplayedInTheMessage()
        {
            var buffer = EventBuffer.Empty(Guid.NewGuid())
                         .Add(new object[]
            {
                new EmptyEvent(),
                new SimpleEvent(),
                new SimpleEvent()
            });

            var x = Assert.Catch <AssertionFailed>(() =>
                                                   AggregateRootAssert.HasUncommittedEvents(buffer,
                                                                                            new EmptyEvent(),
                                                                                            new OtherEvent(),
                                                                                            new SimpleEvent()
                                                                                            ));

            Assert.AreEqual(@"Assertion failed:
[0] EmptyEvent
[1] Expected: TestEvents.OtherEvent
    Actual:   TestEvents.SimpleEvent
[2] SimpleEvent
", x.Message);
        }
        public void HasUncommittedEvents_IsTrue()
        {
            var buffer = EventBuffer.Empty(Guid.NewGuid())
                         .Add(new object[]
            {
                new EmptyEvent(),
                new SimpleEvent {
                    Value = 3
                },
                new OtherEvent {
                    Value = 3
                }
            });

            AggregateRootAssert.HasUncommittedEvents(buffer,
                                                     new EmptyEvent(),
                                                     new SimpleEvent {
                Value = 3
            },
                                                     new OtherEvent {
                Value = 3
            }
                                                     );
        }